# 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 _itkVectorContainerPython
else:
    import _itkVectorContainerPython

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_vectorPython
import itk.stdcomplexPython
import itk.pyBasePython
import itk.vnl_matrixPython
import itk.vnl_vector_refPython
import itk.itkFixedArrayPython
import itk.itkOffsetPython
import itk.itkSizePython
import itk.itkContinuousIndexPython
import itk.itkIndexPython
import itk.itkPointPython
import itk.ITKCommonBasePython
import itk.itkMatrixPython
import itk.itkCovariantVectorPython
import itk.vnl_matrix_fixedPython
import itk.itkArrayPython

def itkDataObjectDecoratorVCUCD_New():
    return itkDataObjectDecoratorVCUCD.New()

class itkDataObjectDecoratorVCUCD(itk.ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkDataObjectDecoratorVCUCD class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkDataObjectDecoratorVCUCD_Pointer"""
        return _itkVectorContainerPython.itkDataObjectDecoratorVCUCD___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkDataObjectDecoratorVCUCD_Pointer"""
        return _itkVectorContainerPython.itkDataObjectDecoratorVCUCD_Clone(self)

    def Set(self, val):
        r"""
        Set(self, val)

        Parameters
        ----------
        val: itkVectorContainerUCD const *

        """
        return _itkVectorContainerPython.itkDataObjectDecoratorVCUCD_Set(self, val)

    def Get(self):
        r"""Get(self) -> itkVectorContainerUCD"""
        return _itkVectorContainerPython.itkDataObjectDecoratorVCUCD_Get(self)

    def GetModifiable(self):
        r"""GetModifiable(self) -> itkVectorContainerUCD"""
        return _itkVectorContainerPython.itkDataObjectDecoratorVCUCD_GetModifiable(self)

    def Graft(self, *args):
        r"""
        Graft(self, arg0)

        Parameters
        ----------
        arg0: itkDataObject const *

        Graft(self, data)

        Parameters
        ----------
        data: itkDataObjectDecoratorVCUCD const *

        """
        return _itkVectorContainerPython.itkDataObjectDecoratorVCUCD_Graft(self, *args)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkDataObjectDecoratorVCUCD

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

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

        """
        return _itkVectorContainerPython.itkDataObjectDecoratorVCUCD_cast(obj)

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

        Create a new object of the class itkDataObjectDecoratorVCUCD 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:

          itkDataObjectDecoratorVCUCD.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkDataObjectDecoratorVCUCD in _itkVectorContainerPython:
_itkVectorContainerPython.itkDataObjectDecoratorVCUCD_swigregister(itkDataObjectDecoratorVCUCD)

def itkVectorContainerUCD_New():
    return itkVectorContainerUCD.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerUCD_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUCD___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUCD_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUCD_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> vectorD"""
        return _itkVectorContainerPython.itkVectorContainerUCD_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> vectorD"""
        return _itkVectorContainerPython.itkVectorContainerUCD_CastToSTLConstContainer(self)

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

        Parameters
        ----------
        arg0: unsigned char

        ElementAt(self, arg0) -> double const &

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCD_ElementAt(self, *args)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCD_CreateElementAt(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCD_GetElement(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char
        arg1: double

        """
        return _itkVectorContainerPython.itkVectorContainerUCD_SetElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned char
        arg1: double

        """
        return _itkVectorContainerPython.itkVectorContainerUCD_InsertElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCD_IndexExists(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerUCD_GetElementIfIndexExists(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCD_CreateIndex(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCD_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned char"""
        return _itkVectorContainerPython.itkVectorContainerUCD_Size(self)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCD_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerUCD_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerUCD_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUCD

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerUCD_cast(obj)

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

        Create a new object of the class itkVectorContainerUCD 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:

          itkVectorContainerUCD.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUCD in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUCD_swigregister(itkVectorContainerUCD)

def itkVectorContainerUCF_New():
    return itkVectorContainerUCF.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerUCF_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUCF___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUCF_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUCF_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> vectorF"""
        return _itkVectorContainerPython.itkVectorContainerUCF_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> vectorF"""
        return _itkVectorContainerPython.itkVectorContainerUCF_CastToSTLConstContainer(self)

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

        Parameters
        ----------
        arg0: unsigned char

        ElementAt(self, arg0) -> float const &

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCF_ElementAt(self, *args)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCF_CreateElementAt(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCF_GetElement(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char
        arg1: float

        """
        return _itkVectorContainerPython.itkVectorContainerUCF_SetElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned char
        arg1: float

        """
        return _itkVectorContainerPython.itkVectorContainerUCF_InsertElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCF_IndexExists(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerUCF_GetElementIfIndexExists(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCF_CreateIndex(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCF_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned char"""
        return _itkVectorContainerPython.itkVectorContainerUCF_Size(self)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCF_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerUCF_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerUCF_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUCF

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerUCF_cast(obj)

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

        Create a new object of the class itkVectorContainerUCF 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:

          itkVectorContainerUCF.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUCF in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUCF_swigregister(itkVectorContainerUCF)

def itkVectorContainerUCO2_New():
    return itkVectorContainerUCO2.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerUCO2_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUCO2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUCO2_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUCO2_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkOffset2,std::allocator< itkOffset2 > > &"""
        return _itkVectorContainerPython.itkVectorContainerUCO2_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkOffset2,std::allocator< itkOffset2 > > const &"""
        return _itkVectorContainerPython.itkVectorContainerUCO2_CastToSTLConstContainer(self)

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

        Parameters
        ----------
        arg0: unsigned char

        ElementAt(self, arg0) -> itkOffset2

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCO2_ElementAt(self, *args)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCO2_CreateElementAt(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCO2_GetElement(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char
        arg1: itkOffset2

        """
        return _itkVectorContainerPython.itkVectorContainerUCO2_SetElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned char
        arg1: itkOffset2

        """
        return _itkVectorContainerPython.itkVectorContainerUCO2_InsertElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCO2_IndexExists(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char
        arg1: itkOffset2 *

        """
        return _itkVectorContainerPython.itkVectorContainerUCO2_GetElementIfIndexExists(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCO2_CreateIndex(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCO2_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned char"""
        return _itkVectorContainerPython.itkVectorContainerUCO2_Size(self)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCO2_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerUCO2_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerUCO2_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUCO2

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerUCO2_cast(obj)

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

        Create a new object of the class itkVectorContainerUCO2 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:

          itkVectorContainerUCO2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUCO2 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUCO2_swigregister(itkVectorContainerUCO2)

def itkVectorContainerUCO3_New():
    return itkVectorContainerUCO3.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerUCO3_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUCO3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUCO3_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUCO3_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkOffset3,std::allocator< itkOffset3 > > &"""
        return _itkVectorContainerPython.itkVectorContainerUCO3_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkOffset3,std::allocator< itkOffset3 > > const &"""
        return _itkVectorContainerPython.itkVectorContainerUCO3_CastToSTLConstContainer(self)

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

        Parameters
        ----------
        arg0: unsigned char

        ElementAt(self, arg0) -> itkOffset3

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCO3_ElementAt(self, *args)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCO3_CreateElementAt(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCO3_GetElement(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char
        arg1: itkOffset3

        """
        return _itkVectorContainerPython.itkVectorContainerUCO3_SetElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned char
        arg1: itkOffset3

        """
        return _itkVectorContainerPython.itkVectorContainerUCO3_InsertElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCO3_IndexExists(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char
        arg1: itkOffset3 *

        """
        return _itkVectorContainerPython.itkVectorContainerUCO3_GetElementIfIndexExists(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCO3_CreateIndex(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCO3_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned char"""
        return _itkVectorContainerPython.itkVectorContainerUCO3_Size(self)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCO3_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerUCO3_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerUCO3_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUCO3

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerUCO3_cast(obj)

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

        Create a new object of the class itkVectorContainerUCO3 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:

          itkVectorContainerUCO3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUCO3 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUCO3_swigregister(itkVectorContainerUCO3)

def itkVectorContainerUCSS_New():
    return itkVectorContainerUCSS.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerUCSS_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUCSS___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUCSS_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUCSS_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> vectorSS"""
        return _itkVectorContainerPython.itkVectorContainerUCSS_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> vectorSS"""
        return _itkVectorContainerPython.itkVectorContainerUCSS_CastToSTLConstContainer(self)

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

        Parameters
        ----------
        arg0: unsigned char

        ElementAt(self, arg0) -> short const &

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCSS_ElementAt(self, *args)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCSS_CreateElementAt(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCSS_GetElement(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char
        arg1: short

        """
        return _itkVectorContainerPython.itkVectorContainerUCSS_SetElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned char
        arg1: short

        """
        return _itkVectorContainerPython.itkVectorContainerUCSS_InsertElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCSS_IndexExists(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char
        arg1: short *

        """
        return _itkVectorContainerPython.itkVectorContainerUCSS_GetElementIfIndexExists(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCSS_CreateIndex(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCSS_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned char"""
        return _itkVectorContainerPython.itkVectorContainerUCSS_Size(self)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCSS_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerUCSS_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerUCSS_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUCSS

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerUCSS_cast(obj)

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

        Create a new object of the class itkVectorContainerUCSS 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:

          itkVectorContainerUCSS.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUCSS in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUCSS_swigregister(itkVectorContainerUCSS)

def itkVectorContainerUCUC_New():
    return itkVectorContainerUCUC.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerUCUC_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUCUC___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUCUC_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUCUC_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> vectorUC"""
        return _itkVectorContainerPython.itkVectorContainerUCUC_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> vectorUC"""
        return _itkVectorContainerPython.itkVectorContainerUCUC_CastToSTLConstContainer(self)

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

        Parameters
        ----------
        arg0: unsigned char

        ElementAt(self, arg0) -> unsigned char const &

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCUC_ElementAt(self, *args)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCUC_CreateElementAt(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCUC_GetElement(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char
        arg1: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCUC_SetElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned char
        arg1: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCUC_InsertElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCUC_IndexExists(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char
        arg1: unsigned char *

        """
        return _itkVectorContainerPython.itkVectorContainerUCUC_GetElementIfIndexExists(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCUC_CreateIndex(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCUC_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned char"""
        return _itkVectorContainerPython.itkVectorContainerUCUC_Size(self)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCUC_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerUCUC_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerUCUC_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUCUC

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerUCUC_cast(obj)

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

        Create a new object of the class itkVectorContainerUCUC 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:

          itkVectorContainerUCUC.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUCUC in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUCUC_swigregister(itkVectorContainerUCUC)

def itkVectorContainerUCUI_New():
    return itkVectorContainerUCUI.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerUCUI_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUCUI___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUCUI_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUCUI_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> vectorUI"""
        return _itkVectorContainerPython.itkVectorContainerUCUI_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> vectorUI"""
        return _itkVectorContainerPython.itkVectorContainerUCUI_CastToSTLConstContainer(self)

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

        Parameters
        ----------
        arg0: unsigned char

        ElementAt(self, arg0) -> unsigned int const &

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCUI_ElementAt(self, *args)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCUI_CreateElementAt(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCUI_GetElement(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char
        arg1: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUCUI_SetElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned char
        arg1: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUCUI_InsertElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCUI_IndexExists(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char
        arg1: unsigned int *

        """
        return _itkVectorContainerPython.itkVectorContainerUCUI_GetElementIfIndexExists(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCUI_CreateIndex(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCUI_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned char"""
        return _itkVectorContainerPython.itkVectorContainerUCUI_Size(self)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCUI_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerUCUI_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerUCUI_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUCUI

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerUCUI_cast(obj)

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

        Create a new object of the class itkVectorContainerUCUI 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:

          itkVectorContainerUCUI.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUCUI in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUCUI_swigregister(itkVectorContainerUCUI)

def itkVectorContainerUCUL_New():
    return itkVectorContainerUCUL.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerUCUL_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUCUL___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUCUL_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUCUL_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> vectorUL"""
        return _itkVectorContainerPython.itkVectorContainerUCUL_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> vectorUL"""
        return _itkVectorContainerPython.itkVectorContainerUCUL_CastToSTLConstContainer(self)

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

        Parameters
        ----------
        arg0: unsigned char

        ElementAt(self, arg0) -> unsigned long const &

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCUL_ElementAt(self, *args)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCUL_CreateElementAt(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCUL_GetElement(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char
        arg1: unsigned long

        """
        return _itkVectorContainerPython.itkVectorContainerUCUL_SetElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned char
        arg1: unsigned long

        """
        return _itkVectorContainerPython.itkVectorContainerUCUL_InsertElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCUL_IndexExists(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerUCUL_GetElementIfIndexExists(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCUL_CreateIndex(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCUL_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned char"""
        return _itkVectorContainerPython.itkVectorContainerUCUL_Size(self)

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

        Parameters
        ----------
        arg0: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUCUL_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerUCUL_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerUCUL_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUCUL

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerUCUL_cast(obj)

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

        Create a new object of the class itkVectorContainerUCUL 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:

          itkVectorContainerUCUL.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUCUL in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUCUL_swigregister(itkVectorContainerUCUL)

def itkVectorContainerUICID2_New():
    return itkVectorContainerUICID2.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerUICID2_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUICID2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUICID2_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUICID2_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkContinuousIndexD2,std::allocator< itkContinuousIndexD2 > > &"""
        return _itkVectorContainerPython.itkVectorContainerUICID2_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkContinuousIndexD2,std::allocator< itkContinuousIndexD2 > > const &"""
        return _itkVectorContainerPython.itkVectorContainerUICID2_CastToSTLConstContainer(self)

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

        Parameters
        ----------
        arg0: unsigned int

        ElementAt(self, arg0) -> itkContinuousIndexD2

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUICID2_ElementAt(self, *args)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUICID2_CreateElementAt(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUICID2_GetElement(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkContinuousIndexD2

        """
        return _itkVectorContainerPython.itkVectorContainerUICID2_SetElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkContinuousIndexD2

        """
        return _itkVectorContainerPython.itkVectorContainerUICID2_InsertElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUICID2_IndexExists(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkContinuousIndexD2 *

        """
        return _itkVectorContainerPython.itkVectorContainerUICID2_GetElementIfIndexExists(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUICID2_CreateIndex(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUICID2_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned int"""
        return _itkVectorContainerPython.itkVectorContainerUICID2_Size(self)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUICID2_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerUICID2_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerUICID2_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUICID2

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerUICID2_cast(obj)

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

        Create a new object of the class itkVectorContainerUICID2 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:

          itkVectorContainerUICID2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUICID2 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUICID2_swigregister(itkVectorContainerUICID2)

def itkVectorContainerUICID3_New():
    return itkVectorContainerUICID3.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerUICID3_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUICID3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUICID3_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUICID3_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkContinuousIndexD3,std::allocator< itkContinuousIndexD3 > > &"""
        return _itkVectorContainerPython.itkVectorContainerUICID3_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkContinuousIndexD3,std::allocator< itkContinuousIndexD3 > > const &"""
        return _itkVectorContainerPython.itkVectorContainerUICID3_CastToSTLConstContainer(self)

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

        Parameters
        ----------
        arg0: unsigned int

        ElementAt(self, arg0) -> itkContinuousIndexD3

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUICID3_ElementAt(self, *args)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUICID3_CreateElementAt(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUICID3_GetElement(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkContinuousIndexD3

        """
        return _itkVectorContainerPython.itkVectorContainerUICID3_SetElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkContinuousIndexD3

        """
        return _itkVectorContainerPython.itkVectorContainerUICID3_InsertElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUICID3_IndexExists(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkContinuousIndexD3 *

        """
        return _itkVectorContainerPython.itkVectorContainerUICID3_GetElementIfIndexExists(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUICID3_CreateIndex(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUICID3_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned int"""
        return _itkVectorContainerPython.itkVectorContainerUICID3_Size(self)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUICID3_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerUICID3_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerUICID3_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUICID3

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerUICID3_cast(obj)

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

        Create a new object of the class itkVectorContainerUICID3 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:

          itkVectorContainerUICID3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUICID3 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUICID3_swigregister(itkVectorContainerUICID3)

def itkVectorContainerUIUC_New():
    return itkVectorContainerUIUC.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerUIUC_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUIUC___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUIUC_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUIUC_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> vectorUC"""
        return _itkVectorContainerPython.itkVectorContainerUIUC_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> vectorUC"""
        return _itkVectorContainerPython.itkVectorContainerUIUC_CastToSTLConstContainer(self)

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

        Parameters
        ----------
        arg0: unsigned int

        ElementAt(self, arg0) -> unsigned char const &

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIUC_ElementAt(self, *args)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIUC_CreateElementAt(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIUC_GetElement(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUIUC_SetElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerUIUC_InsertElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIUC_IndexExists(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: unsigned char *

        """
        return _itkVectorContainerPython.itkVectorContainerUIUC_GetElementIfIndexExists(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIUC_CreateIndex(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIUC_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned int"""
        return _itkVectorContainerPython.itkVectorContainerUIUC_Size(self)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIUC_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerUIUC_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerUIUC_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUIUC

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerUIUC_cast(obj)

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

        Create a new object of the class itkVectorContainerUIUC 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:

          itkVectorContainerUIUC.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUIUC in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUIUC_swigregister(itkVectorContainerUIUC)

def itkVectorContainerUIUI_New():
    return itkVectorContainerUIUI.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerUIUI_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUIUI___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUIUI_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUIUI_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> vectorUI"""
        return _itkVectorContainerPython.itkVectorContainerUIUI_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> vectorUI"""
        return _itkVectorContainerPython.itkVectorContainerUIUI_CastToSTLConstContainer(self)

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

        Parameters
        ----------
        arg0: unsigned int

        ElementAt(self, arg0) -> unsigned int const &

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIUI_ElementAt(self, *args)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIUI_CreateElementAt(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIUI_GetElement(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIUI_SetElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIUI_InsertElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIUI_IndexExists(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: unsigned int *

        """
        return _itkVectorContainerPython.itkVectorContainerUIUI_GetElementIfIndexExists(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIUI_CreateIndex(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIUI_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned int"""
        return _itkVectorContainerPython.itkVectorContainerUIUI_Size(self)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIUI_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerUIUI_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerUIUI_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUIUI

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerUIUI_cast(obj)

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

        Create a new object of the class itkVectorContainerUIUI 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:

          itkVectorContainerUIUI.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUIUI in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUIUI_swigregister(itkVectorContainerUIUI)

def itkVectorContainerUIUL_New():
    return itkVectorContainerUIUL.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerUIUL_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUIUL___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUIUL_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUIUL_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> vectorUL"""
        return _itkVectorContainerPython.itkVectorContainerUIUL_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> vectorUL"""
        return _itkVectorContainerPython.itkVectorContainerUIUL_CastToSTLConstContainer(self)

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

        Parameters
        ----------
        arg0: unsigned int

        ElementAt(self, arg0) -> unsigned long const &

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIUL_ElementAt(self, *args)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIUL_CreateElementAt(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIUL_GetElement(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: unsigned long

        """
        return _itkVectorContainerPython.itkVectorContainerUIUL_SetElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: unsigned long

        """
        return _itkVectorContainerPython.itkVectorContainerUIUL_InsertElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIUL_IndexExists(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerUIUL_GetElementIfIndexExists(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIUL_CreateIndex(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIUL_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned int"""
        return _itkVectorContainerPython.itkVectorContainerUIUL_Size(self)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIUL_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerUIUL_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerUIUL_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUIUL

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerUIUL_cast(obj)

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

        Create a new object of the class itkVectorContainerUIUL 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:

          itkVectorContainerUIUL.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUIUL in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUIUL_swigregister(itkVectorContainerUIUL)

def itkVectorContainerUIVUC1_New():
    return itkVectorContainerUIVUC1.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerUIVUC1_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUIVUC1___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUIVUC1_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerUIVUC1_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkVectorUC1,std::allocator< itkVectorUC1 > > &"""
        return _itkVectorContainerPython.itkVectorContainerUIVUC1_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkVectorUC1,std::allocator< itkVectorUC1 > > const &"""
        return _itkVectorContainerPython.itkVectorContainerUIVUC1_CastToSTLConstContainer(self)

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

        Parameters
        ----------
        arg0: unsigned int

        ElementAt(self, arg0) -> itkVectorUC1

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIVUC1_ElementAt(self, *args)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIVUC1_CreateElementAt(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIVUC1_GetElement(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkVectorUC1

        """
        return _itkVectorContainerPython.itkVectorContainerUIVUC1_SetElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkVectorUC1

        """
        return _itkVectorContainerPython.itkVectorContainerUIVUC1_InsertElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIVUC1_IndexExists(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkVectorUC1 *

        """
        return _itkVectorContainerPython.itkVectorContainerUIVUC1_GetElementIfIndexExists(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIVUC1_CreateIndex(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIVUC1_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned int"""
        return _itkVectorContainerPython.itkVectorContainerUIVUC1_Size(self)

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

        Parameters
        ----------
        arg0: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerUIVUC1_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerUIVUC1_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerUIVUC1_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUIVUC1

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerUIVUC1_cast(obj)

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

        Create a new object of the class itkVectorContainerUIVUC1 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:

          itkVectorContainerUIVUC1.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUIVUC1 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUIVUC1_swigregister(itkVectorContainerUIVUC1)

def itkVectorContainerULAD_New():
    return itkVectorContainerULAD.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerULAD_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULAD___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULAD_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULAD_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkArrayD,std::allocator< itkArrayD > > &"""
        return _itkVectorContainerPython.itkVectorContainerULAD_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkArrayD,std::allocator< itkArrayD > > const &"""
        return _itkVectorContainerPython.itkVectorContainerULAD_CastToSTLConstContainer(self)

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

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

        ElementAt(self, arg0) -> itkArrayD

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

        """
        return _itkVectorContainerPython.itkVectorContainerULAD_ElementAt(self, *args)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULAD_CreateElementAt(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULAD_GetElement(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkArrayD

        """
        return _itkVectorContainerPython.itkVectorContainerULAD_SetElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkArrayD

        """
        return _itkVectorContainerPython.itkVectorContainerULAD_InsertElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULAD_IndexExists(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULAD_GetElementIfIndexExists(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULAD_CreateIndex(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULAD_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkVectorContainerPython.itkVectorContainerULAD_Size(self)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULAD_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerULAD_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerULAD_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULAD

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULAD_cast(obj)

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

        Create a new object of the class itkVectorContainerULAD 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:

          itkVectorContainerULAD.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULAD in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULAD_swigregister(itkVectorContainerULAD)

def itkVectorContainerULAF_New():
    return itkVectorContainerULAF.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerULAF_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULAF___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULAF_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULAF_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkArrayF,std::allocator< itkArrayF > > &"""
        return _itkVectorContainerPython.itkVectorContainerULAF_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkArrayF,std::allocator< itkArrayF > > const &"""
        return _itkVectorContainerPython.itkVectorContainerULAF_CastToSTLConstContainer(self)

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

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

        ElementAt(self, arg0) -> itkArrayF

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

        """
        return _itkVectorContainerPython.itkVectorContainerULAF_ElementAt(self, *args)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULAF_CreateElementAt(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULAF_GetElement(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkArrayF

        """
        return _itkVectorContainerPython.itkVectorContainerULAF_SetElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkArrayF

        """
        return _itkVectorContainerPython.itkVectorContainerULAF_InsertElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULAF_IndexExists(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULAF_GetElementIfIndexExists(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULAF_CreateIndex(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULAF_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkVectorContainerPython.itkVectorContainerULAF_Size(self)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULAF_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerULAF_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerULAF_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULAF

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULAF_cast(obj)

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

        Create a new object of the class itkVectorContainerULAF 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:

          itkVectorContainerULAF.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULAF in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULAF_swigregister(itkVectorContainerULAF)

def itkVectorContainerULD_New():
    return itkVectorContainerULD.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerULD_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULD___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULD_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULD_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> vectorD"""
        return _itkVectorContainerPython.itkVectorContainerULD_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> vectorD"""
        return _itkVectorContainerPython.itkVectorContainerULD_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 _itkVectorContainerPython.itkVectorContainerULD_ElementAt(self, *args)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULD_CreateElementAt(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULD_GetElement(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULD_SetElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULD_InsertElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULD_IndexExists(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULD_GetElementIfIndexExists(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULD_CreateIndex(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULD_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkVectorContainerPython.itkVectorContainerULD_Size(self)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULD_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerULD_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerULD_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULD

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULD_cast(obj)

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

        Create a new object of the class itkVectorContainerULD 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:

          itkVectorContainerULD.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULD in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULD_swigregister(itkVectorContainerULD)

def itkVectorContainerULF_New():
    return itkVectorContainerULF.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerULF_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULF___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULF_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULF_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> vectorF"""
        return _itkVectorContainerPython.itkVectorContainerULF_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> vectorF"""
        return _itkVectorContainerPython.itkVectorContainerULF_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 _itkVectorContainerPython.itkVectorContainerULF_ElementAt(self, *args)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULF_CreateElementAt(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULF_GetElement(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULF_SetElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULF_InsertElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULF_IndexExists(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULF_GetElementIfIndexExists(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULF_CreateIndex(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULF_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkVectorContainerPython.itkVectorContainerULF_Size(self)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULF_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerULF_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerULF_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULF

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULF_cast(obj)

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

        Create a new object of the class itkVectorContainerULF 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:

          itkVectorContainerULF.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULF in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULF_swigregister(itkVectorContainerULF)

def itkVectorContainerULMD22_New():
    return itkVectorContainerULMD22.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerULMD22_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULMD22___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULMD22_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULMD22_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkMatrixD22,std::allocator< itkMatrixD22 > > &"""
        return _itkVectorContainerPython.itkVectorContainerULMD22_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkMatrixD22,std::allocator< itkMatrixD22 > > const &"""
        return _itkVectorContainerPython.itkVectorContainerULMD22_CastToSTLConstContainer(self)

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

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

        ElementAt(self, arg0) -> itkMatrixD22

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMD22_ElementAt(self, *args)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMD22_CreateElementAt(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMD22_GetElement(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkMatrixD22

        """
        return _itkVectorContainerPython.itkVectorContainerULMD22_SetElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkMatrixD22

        """
        return _itkVectorContainerPython.itkVectorContainerULMD22_InsertElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMD22_IndexExists(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMD22_GetElementIfIndexExists(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMD22_CreateIndex(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMD22_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkVectorContainerPython.itkVectorContainerULMD22_Size(self)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMD22_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerULMD22_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerULMD22_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULMD22

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMD22_cast(obj)

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

        Create a new object of the class itkVectorContainerULMD22 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:

          itkVectorContainerULMD22.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULMD22 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULMD22_swigregister(itkVectorContainerULMD22)

def itkVectorContainerULMD33_New():
    return itkVectorContainerULMD33.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerULMD33_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULMD33___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULMD33_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULMD33_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkMatrixD33,std::allocator< itkMatrixD33 > > &"""
        return _itkVectorContainerPython.itkVectorContainerULMD33_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkMatrixD33,std::allocator< itkMatrixD33 > > const &"""
        return _itkVectorContainerPython.itkVectorContainerULMD33_CastToSTLConstContainer(self)

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

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

        ElementAt(self, arg0) -> itkMatrixD33

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMD33_ElementAt(self, *args)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMD33_CreateElementAt(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMD33_GetElement(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkMatrixD33

        """
        return _itkVectorContainerPython.itkVectorContainerULMD33_SetElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkMatrixD33

        """
        return _itkVectorContainerPython.itkVectorContainerULMD33_InsertElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMD33_IndexExists(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMD33_GetElementIfIndexExists(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMD33_CreateIndex(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMD33_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkVectorContainerPython.itkVectorContainerULMD33_Size(self)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMD33_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerULMD33_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerULMD33_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULMD33

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMD33_cast(obj)

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

        Create a new object of the class itkVectorContainerULMD33 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:

          itkVectorContainerULMD33.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULMD33 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULMD33_swigregister(itkVectorContainerULMD33)

def itkVectorContainerULMF22_New():
    return itkVectorContainerULMF22.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerULMF22_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULMF22___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULMF22_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULMF22_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkMatrixF22,std::allocator< itkMatrixF22 > > &"""
        return _itkVectorContainerPython.itkVectorContainerULMF22_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkMatrixF22,std::allocator< itkMatrixF22 > > const &"""
        return _itkVectorContainerPython.itkVectorContainerULMF22_CastToSTLConstContainer(self)

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

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

        ElementAt(self, arg0) -> itkMatrixF22

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMF22_ElementAt(self, *args)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMF22_CreateElementAt(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMF22_GetElement(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkMatrixF22

        """
        return _itkVectorContainerPython.itkVectorContainerULMF22_SetElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkMatrixF22

        """
        return _itkVectorContainerPython.itkVectorContainerULMF22_InsertElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMF22_IndexExists(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMF22_GetElementIfIndexExists(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMF22_CreateIndex(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMF22_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkVectorContainerPython.itkVectorContainerULMF22_Size(self)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMF22_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerULMF22_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerULMF22_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULMF22

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMF22_cast(obj)

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

        Create a new object of the class itkVectorContainerULMF22 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:

          itkVectorContainerULMF22.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULMF22 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULMF22_swigregister(itkVectorContainerULMF22)

def itkVectorContainerULMF33_New():
    return itkVectorContainerULMF33.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerULMF33_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULMF33___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULMF33_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULMF33_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkMatrixF33,std::allocator< itkMatrixF33 > > &"""
        return _itkVectorContainerPython.itkVectorContainerULMF33_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkMatrixF33,std::allocator< itkMatrixF33 > > const &"""
        return _itkVectorContainerPython.itkVectorContainerULMF33_CastToSTLConstContainer(self)

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

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

        ElementAt(self, arg0) -> itkMatrixF33

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMF33_ElementAt(self, *args)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMF33_CreateElementAt(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMF33_GetElement(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkMatrixF33

        """
        return _itkVectorContainerPython.itkVectorContainerULMF33_SetElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkMatrixF33

        """
        return _itkVectorContainerPython.itkVectorContainerULMF33_InsertElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMF33_IndexExists(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMF33_GetElementIfIndexExists(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMF33_CreateIndex(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMF33_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkVectorContainerPython.itkVectorContainerULMF33_Size(self)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMF33_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerULMF33_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerULMF33_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULMF33

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULMF33_cast(obj)

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

        Create a new object of the class itkVectorContainerULMF33 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:

          itkVectorContainerULMF33.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULMF33 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULMF33_swigregister(itkVectorContainerULMF33)

def itkVectorContainerULPD2_New():
    return itkVectorContainerULPD2.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerULPD2_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULPD2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULPD2_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULPD2_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> vectoritkPointD2"""
        return _itkVectorContainerPython.itkVectorContainerULPD2_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> vectoritkPointD2"""
        return _itkVectorContainerPython.itkVectorContainerULPD2_CastToSTLConstContainer(self)

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

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

        ElementAt(self, arg0) -> itkPointD2

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPD2_ElementAt(self, *args)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPD2_CreateElementAt(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPD2_GetElement(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPD2_SetElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPD2_InsertElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPD2_IndexExists(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPD2_GetElementIfIndexExists(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPD2_CreateIndex(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPD2_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkVectorContainerPython.itkVectorContainerULPD2_Size(self)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPD2_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerULPD2_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerULPD2_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULPD2

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPD2_cast(obj)

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

        Create a new object of the class itkVectorContainerULPD2 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:

          itkVectorContainerULPD2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULPD2 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULPD2_swigregister(itkVectorContainerULPD2)

def itkVectorContainerULPD3_New():
    return itkVectorContainerULPD3.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerULPD3_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULPD3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULPD3_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULPD3_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> vectoritkPointD3"""
        return _itkVectorContainerPython.itkVectorContainerULPD3_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> vectoritkPointD3"""
        return _itkVectorContainerPython.itkVectorContainerULPD3_CastToSTLConstContainer(self)

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

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

        ElementAt(self, arg0) -> itkPointD3

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPD3_ElementAt(self, *args)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPD3_CreateElementAt(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPD3_GetElement(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPD3_SetElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPD3_InsertElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPD3_IndexExists(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPD3_GetElementIfIndexExists(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPD3_CreateIndex(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPD3_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkVectorContainerPython.itkVectorContainerULPD3_Size(self)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPD3_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerULPD3_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerULPD3_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULPD3

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPD3_cast(obj)

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

        Create a new object of the class itkVectorContainerULPD3 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:

          itkVectorContainerULPD3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULPD3 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULPD3_swigregister(itkVectorContainerULPD3)

def itkVectorContainerULPF2_New():
    return itkVectorContainerULPF2.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerULPF2_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULPF2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULPF2_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULPF2_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> vectoritkPointF2"""
        return _itkVectorContainerPython.itkVectorContainerULPF2_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> vectoritkPointF2"""
        return _itkVectorContainerPython.itkVectorContainerULPF2_CastToSTLConstContainer(self)

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

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

        ElementAt(self, arg0) -> itkPointF2

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPF2_ElementAt(self, *args)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPF2_CreateElementAt(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPF2_GetElement(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPF2_SetElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPF2_InsertElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPF2_IndexExists(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPF2_GetElementIfIndexExists(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPF2_CreateIndex(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPF2_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkVectorContainerPython.itkVectorContainerULPF2_Size(self)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPF2_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerULPF2_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerULPF2_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULPF2

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPF2_cast(obj)

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

        Create a new object of the class itkVectorContainerULPF2 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:

          itkVectorContainerULPF2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULPF2 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULPF2_swigregister(itkVectorContainerULPF2)

def itkVectorContainerULPF3_New():
    return itkVectorContainerULPF3.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerULPF3_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULPF3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULPF3_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULPF3_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> vectoritkPointF3"""
        return _itkVectorContainerPython.itkVectorContainerULPF3_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> vectoritkPointF3"""
        return _itkVectorContainerPython.itkVectorContainerULPF3_CastToSTLConstContainer(self)

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

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

        ElementAt(self, arg0) -> itkPointF3

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPF3_ElementAt(self, *args)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPF3_CreateElementAt(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPF3_GetElement(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPF3_SetElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPF3_InsertElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPF3_IndexExists(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPF3_GetElementIfIndexExists(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPF3_CreateIndex(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPF3_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkVectorContainerPython.itkVectorContainerULPF3_Size(self)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPF3_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerULPF3_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerULPF3_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULPF3

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULPF3_cast(obj)

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

        Create a new object of the class itkVectorContainerULPF3 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:

          itkVectorContainerULPF3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULPF3 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULPF3_swigregister(itkVectorContainerULPF3)

def itkVectorContainerULSS_New():
    return itkVectorContainerULSS.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerULSS_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULSS___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULSS_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULSS_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> vectorSS"""
        return _itkVectorContainerPython.itkVectorContainerULSS_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> vectorSS"""
        return _itkVectorContainerPython.itkVectorContainerULSS_CastToSTLConstContainer(self)

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

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

        ElementAt(self, arg0) -> short const &

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

        """
        return _itkVectorContainerPython.itkVectorContainerULSS_ElementAt(self, *args)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULSS_CreateElementAt(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULSS_GetElement(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned long
        arg1: short

        """
        return _itkVectorContainerPython.itkVectorContainerULSS_SetElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned long
        arg1: short

        """
        return _itkVectorContainerPython.itkVectorContainerULSS_InsertElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULSS_IndexExists(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULSS_GetElementIfIndexExists(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULSS_CreateIndex(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULSS_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkVectorContainerPython.itkVectorContainerULSS_Size(self)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULSS_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerULSS_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerULSS_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULSS

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULSS_cast(obj)

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

        Create a new object of the class itkVectorContainerULSS 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:

          itkVectorContainerULSS.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULSS in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULSS_swigregister(itkVectorContainerULSS)

def itkVectorContainerULSUL_New():
    return itkVectorContainerULSUL.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerULSUL_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULSUL___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULSUL_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULSUL_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> vectorsetUL"""
        return _itkVectorContainerPython.itkVectorContainerULSUL_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> vectorsetUL"""
        return _itkVectorContainerPython.itkVectorContainerULSUL_CastToSTLConstContainer(self)

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

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

        ElementAt(self, arg0) -> setUL

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

        """
        return _itkVectorContainerPython.itkVectorContainerULSUL_ElementAt(self, *args)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULSUL_CreateElementAt(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULSUL_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 _itkVectorContainerPython.itkVectorContainerULSUL_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 _itkVectorContainerPython.itkVectorContainerULSUL_InsertElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULSUL_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 _itkVectorContainerPython.itkVectorContainerULSUL_GetElementIfIndexExists(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULSUL_CreateIndex(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULSUL_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkVectorContainerPython.itkVectorContainerULSUL_Size(self)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULSUL_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerULSUL_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerULSUL_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULSUL

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULSUL_cast(obj)

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

        Create a new object of the class itkVectorContainerULSUL 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:

          itkVectorContainerULSUL.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULSUL in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULSUL_swigregister(itkVectorContainerULSUL)

def itkVectorContainerULUC_New():
    return itkVectorContainerULUC.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerULUC_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULUC___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULUC_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULUC_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> vectorUC"""
        return _itkVectorContainerPython.itkVectorContainerULUC_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> vectorUC"""
        return _itkVectorContainerPython.itkVectorContainerULUC_CastToSTLConstContainer(self)

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

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

        ElementAt(self, arg0) -> unsigned char const &

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUC_ElementAt(self, *args)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUC_CreateElementAt(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUC_GetElement(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned long
        arg1: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerULUC_SetElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned long
        arg1: unsigned char

        """
        return _itkVectorContainerPython.itkVectorContainerULUC_InsertElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUC_IndexExists(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUC_GetElementIfIndexExists(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUC_CreateIndex(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUC_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkVectorContainerPython.itkVectorContainerULUC_Size(self)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUC_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerULUC_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerULUC_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULUC

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUC_cast(obj)

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

        Create a new object of the class itkVectorContainerULUC 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:

          itkVectorContainerULUC.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULUC in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULUC_swigregister(itkVectorContainerULUC)

def itkVectorContainerULUI_New():
    return itkVectorContainerULUI.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerULUI_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULUI___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULUI_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULUI_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> vectorUI"""
        return _itkVectorContainerPython.itkVectorContainerULUI_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> vectorUI"""
        return _itkVectorContainerPython.itkVectorContainerULUI_CastToSTLConstContainer(self)

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

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

        ElementAt(self, arg0) -> unsigned int const &

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUI_ElementAt(self, *args)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUI_CreateElementAt(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUI_GetElement(self, arg0)

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

        Parameters
        ----------
        arg0: unsigned long
        arg1: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerULUI_SetElement(self, arg0, arg1)

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

        Parameters
        ----------
        arg0: unsigned long
        arg1: unsigned int

        """
        return _itkVectorContainerPython.itkVectorContainerULUI_InsertElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUI_IndexExists(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUI_GetElementIfIndexExists(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUI_CreateIndex(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUI_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkVectorContainerPython.itkVectorContainerULUI_Size(self)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUI_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerULUI_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerULUI_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULUI

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUI_cast(obj)

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

        Create a new object of the class itkVectorContainerULUI 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:

          itkVectorContainerULUI.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULUI in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULUI_swigregister(itkVectorContainerULUI)

def itkVectorContainerULUL_New():
    return itkVectorContainerULUL.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerULUL_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULUL___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULUL_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULUL_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> vectorUL"""
        return _itkVectorContainerPython.itkVectorContainerULUL_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> vectorUL"""
        return _itkVectorContainerPython.itkVectorContainerULUL_CastToSTLConstContainer(self)

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

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

        ElementAt(self, arg0) -> unsigned long const &

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUL_ElementAt(self, *args)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUL_CreateElementAt(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUL_GetElement(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUL_SetElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUL_InsertElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUL_IndexExists(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUL_GetElementIfIndexExists(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUL_CreateIndex(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUL_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkVectorContainerPython.itkVectorContainerULUL_Size(self)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUL_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerULUL_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerULUL_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULUL

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULUL_cast(obj)

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

        Create a new object of the class itkVectorContainerULUL 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:

          itkVectorContainerULUL.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULUL in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULUL_swigregister(itkVectorContainerULUL)

def itkVectorContainerULVD2_New():
    return itkVectorContainerULVD2.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerULVD2_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULVD2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULVD2_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULVD2_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkVectorD2,std::allocator< itkVectorD2 > > &"""
        return _itkVectorContainerPython.itkVectorContainerULVD2_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkVectorD2,std::allocator< itkVectorD2 > > const &"""
        return _itkVectorContainerPython.itkVectorContainerULVD2_CastToSTLConstContainer(self)

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

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

        ElementAt(self, arg0) -> itkVectorD2

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVD2_ElementAt(self, *args)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVD2_CreateElementAt(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVD2_GetElement(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVD2_SetElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVD2_InsertElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVD2_IndexExists(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVD2_GetElementIfIndexExists(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVD2_CreateIndex(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVD2_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkVectorContainerPython.itkVectorContainerULVD2_Size(self)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVD2_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerULVD2_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerULVD2_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULVD2

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVD2_cast(obj)

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

        Create a new object of the class itkVectorContainerULVD2 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:

          itkVectorContainerULVD2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULVD2 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULVD2_swigregister(itkVectorContainerULVD2)

def itkVectorContainerULVD3_New():
    return itkVectorContainerULVD3.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerULVD3_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULVD3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULVD3_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULVD3_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkVectorD3,std::allocator< itkVectorD3 > > &"""
        return _itkVectorContainerPython.itkVectorContainerULVD3_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkVectorD3,std::allocator< itkVectorD3 > > const &"""
        return _itkVectorContainerPython.itkVectorContainerULVD3_CastToSTLConstContainer(self)

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

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

        ElementAt(self, arg0) -> itkVectorD3

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVD3_ElementAt(self, *args)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVD3_CreateElementAt(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVD3_GetElement(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVD3_SetElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVD3_InsertElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVD3_IndexExists(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVD3_GetElementIfIndexExists(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVD3_CreateIndex(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVD3_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkVectorContainerPython.itkVectorContainerULVD3_Size(self)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVD3_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerULVD3_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerULVD3_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULVD3

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVD3_cast(obj)

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

        Create a new object of the class itkVectorContainerULVD3 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:

          itkVectorContainerULVD3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULVD3 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULVD3_swigregister(itkVectorContainerULVD3)

def itkVectorContainerULVF2_New():
    return itkVectorContainerULVF2.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerULVF2_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULVF2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULVF2_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULVF2_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkVectorF2,std::allocator< itkVectorF2 > > &"""
        return _itkVectorContainerPython.itkVectorContainerULVF2_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkVectorF2,std::allocator< itkVectorF2 > > const &"""
        return _itkVectorContainerPython.itkVectorContainerULVF2_CastToSTLConstContainer(self)

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

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

        ElementAt(self, arg0) -> itkVectorF2

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVF2_ElementAt(self, *args)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVF2_CreateElementAt(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVF2_GetElement(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVF2_SetElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVF2_InsertElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVF2_IndexExists(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVF2_GetElementIfIndexExists(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVF2_CreateIndex(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVF2_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkVectorContainerPython.itkVectorContainerULVF2_Size(self)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVF2_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerULVF2_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerULVF2_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULVF2

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVF2_cast(obj)

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

        Create a new object of the class itkVectorContainerULVF2 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:

          itkVectorContainerULVF2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULVF2 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULVF2_swigregister(itkVectorContainerULVF2)

def itkVectorContainerULVF3_New():
    return itkVectorContainerULVF3.New()

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorContainerULVF3_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULVF3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULVF3_Pointer"""
        return _itkVectorContainerPython.itkVectorContainerULVF3_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkVectorF3,std::allocator< itkVectorF3 > > &"""
        return _itkVectorContainerPython.itkVectorContainerULVF3_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkVectorF3,std::allocator< itkVectorF3 > > const &"""
        return _itkVectorContainerPython.itkVectorContainerULVF3_CastToSTLConstContainer(self)

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

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

        ElementAt(self, arg0) -> itkVectorF3

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVF3_ElementAt(self, *args)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVF3_CreateElementAt(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVF3_GetElement(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVF3_SetElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVF3_InsertElement(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVF3_IndexExists(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVF3_GetElementIfIndexExists(self, arg0, arg1)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVF3_CreateIndex(self, arg0)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVF3_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkVectorContainerPython.itkVectorContainerULVF3_Size(self)

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVF3_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkVectorContainerPython.itkVectorContainerULVF3_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkVectorContainerPython.itkVectorContainerULVF3_Initialize(self)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULVF3

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

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

        """
        return _itkVectorContainerPython.itkVectorContainerULVF3_cast(obj)

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

        Create a new object of the class itkVectorContainerULVF3 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:

          itkVectorContainerULVF3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULVF3 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULVF3_swigregister(itkVectorContainerULVF3)

