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

from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if getattr(globals().get("__spec__"), "parent", None) or __package__ or "." in __name__:
    from . import _itkVectorContainerPython
else:
    import _itkVectorContainerPython

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

_swig_new_instance_method = _itkVectorContainerPython.SWIG_PyInstanceMethod_New
_swig_new_static_method = _itkVectorContainerPython.SWIG_PyStaticMethod_New

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


import itkMatrixPython
import vnl_matrixPython
import vnl_vectorPython
import stdcomplexPython
import pyBasePython
import itkPointPython
import itkFixedArrayPython
import itkVectorPython
import vnl_vector_refPython
import itkCovariantVectorPython
import vnl_matrix_fixedPython
import ITKCommonBasePython
import itkOffsetPython
import itkSizePython
import itkContinuousIndexPython
import itkIndexPython

def itkDataObjectDecoratorVCUCD_New():
  return itkDataObjectDecoratorVCUCD.New()


def itkVectorContainerUCUC_New():
  return itkVectorContainerUCUC.New()


def itkVectorContainerUCUI_New():
  return itkVectorContainerUCUI.New()


def itkVectorContainerUCUL_New():
  return itkVectorContainerUCUL.New()


def itkVectorContainerUIUC_New():
  return itkVectorContainerUIUC.New()


def itkVectorContainerUIUI_New():
  return itkVectorContainerUIUI.New()


def itkVectorContainerUIUL_New():
  return itkVectorContainerUIUL.New()


def itkVectorContainerULUC_New():
  return itkVectorContainerULUC.New()


def itkVectorContainerULUI_New():
  return itkVectorContainerULUI.New()


def itkVectorContainerULUL_New():
  return itkVectorContainerULUL.New()


def itkVectorContainerULSUL_New():
  return itkVectorContainerULSUL.New()


def itkVectorContainerUIVUC1_New():
  return itkVectorContainerUIVUC1.New()


def itkVectorContainerUCSS_New():
  return itkVectorContainerUCSS.New()


def itkVectorContainerUICID3_New():
  return itkVectorContainerUICID3.New()


def itkVectorContainerUCO3_New():
  return itkVectorContainerUCO3.New()


def itkVectorContainerUICID2_New():
  return itkVectorContainerUICID2.New()


def itkVectorContainerUCO2_New():
  return itkVectorContainerUCO2.New()


def itkVectorContainerULMD33_New():
  return itkVectorContainerULMD33.New()


def itkVectorContainerULPD3_New():
  return itkVectorContainerULPD3.New()


def itkVectorContainerULVD3_New():
  return itkVectorContainerULVD3.New()


def itkVectorContainerULMF33_New():
  return itkVectorContainerULMF33.New()


def itkVectorContainerULPF3_New():
  return itkVectorContainerULPF3.New()


def itkVectorContainerULVF3_New():
  return itkVectorContainerULVF3.New()


def itkVectorContainerULMD22_New():
  return itkVectorContainerULMD22.New()


def itkVectorContainerULPD2_New():
  return itkVectorContainerULPD2.New()


def itkVectorContainerULVD2_New():
  return itkVectorContainerULVD2.New()


def itkVectorContainerULMF22_New():
  return itkVectorContainerULMF22.New()


def itkVectorContainerULPF2_New():
  return itkVectorContainerULPF2.New()


def itkVectorContainerULVF2_New():
  return itkVectorContainerULVF2.New()


def itkVectorContainerUCD_New():
  return itkVectorContainerUCD.New()


def itkVectorContainerULD_New():
  return itkVectorContainerULD.New()


def itkVectorContainerUCF_New():
  return itkVectorContainerUCF.New()


def itkVectorContainerULF_New():
  return itkVectorContainerULF.New()

class itkDataObjectDecoratorVCUCD(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkDataObjectDecoratorVCUCD___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkDataObjectDecoratorVCUCD_Clone)
    Set = _swig_new_instance_method(_itkVectorContainerPython.itkDataObjectDecoratorVCUCD_Set)
    Get = _swig_new_instance_method(_itkVectorContainerPython.itkDataObjectDecoratorVCUCD_Get)
    GetModifiable = _swig_new_instance_method(_itkVectorContainerPython.itkDataObjectDecoratorVCUCD_GetModifiable)
    Graft = _swig_new_instance_method(_itkVectorContainerPython.itkDataObjectDecoratorVCUCD_Graft)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkDataObjectDecoratorVCUCD
    cast = _swig_new_static_method(_itkVectorContainerPython.itkDataObjectDecoratorVCUCD_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkDataObjectDecoratorVCUCD_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkDataObjectDecoratorVCUCD in _itkVectorContainerPython:
_itkVectorContainerPython.itkDataObjectDecoratorVCUCD_swigregister(itkDataObjectDecoratorVCUCD)
class itkVectorContainerUCD(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUCD___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCD_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCD_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCD_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCD_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCD_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCD_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCD_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCD_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCD_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCD_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCD_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCD_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCD_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCD_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCD_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCD_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUCD
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUCD_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCD_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerUCD in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUCD_swigregister(itkVectorContainerUCD)
class itkVectorContainerUCF(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUCF___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCF_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCF_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCF_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCF_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCF_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCF_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCF_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCF_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCF_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCF_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCF_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCF_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCF_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCF_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCF_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCF_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUCF
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUCF_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCF_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerUCF in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUCF_swigregister(itkVectorContainerUCF)
class itkVectorContainerUCO2(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUCO2___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO2_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO2_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO2_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO2_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO2_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO2_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO2_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO2_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO2_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO2_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO2_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO2_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO2_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO2_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO2_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO2_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUCO2
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUCO2_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO2_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerUCO2 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUCO2_swigregister(itkVectorContainerUCO2)
class itkVectorContainerUCO3(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUCO3___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO3_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO3_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO3_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO3_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO3_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO3_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO3_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO3_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO3_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO3_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO3_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO3_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO3_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO3_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO3_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO3_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUCO3
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUCO3_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCO3_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerUCO3 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUCO3_swigregister(itkVectorContainerUCO3)
class itkVectorContainerUCSS(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUCSS___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCSS_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCSS_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCSS_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCSS_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCSS_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCSS_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCSS_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCSS_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCSS_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCSS_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCSS_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCSS_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCSS_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCSS_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCSS_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCSS_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUCSS
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUCSS_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCSS_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerUCSS in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUCSS_swigregister(itkVectorContainerUCSS)
class itkVectorContainerUCUC(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUCUC___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUC_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUC_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUC_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUC_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUC_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUC_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUC_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUC_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUC_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUC_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUC_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUC_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUC_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUC_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUC_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUC_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUCUC
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUCUC_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUC_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerUCUC in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUCUC_swigregister(itkVectorContainerUCUC)
class itkVectorContainerUCUI(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUCUI___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUI_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUI_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUI_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUI_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUI_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUI_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUI_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUI_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUI_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUI_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUI_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUI_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUI_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUI_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUI_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUI_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUCUI
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUCUI_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUI_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerUCUI in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUCUI_swigregister(itkVectorContainerUCUI)
class itkVectorContainerUCUL(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUCUL___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUL_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUL_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUL_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUL_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUL_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUL_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUL_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUL_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUL_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUL_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUL_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUL_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUL_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUL_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUL_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUL_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUCUL
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUCUL_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUCUL_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerUCUL in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUCUL_swigregister(itkVectorContainerUCUL)
class itkVectorContainerUICID2(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUICID2___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID2_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID2_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID2_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID2_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID2_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID2_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID2_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID2_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID2_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID2_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID2_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID2_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID2_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID2_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID2_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID2_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUICID2
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUICID2_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID2_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerUICID2 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUICID2_swigregister(itkVectorContainerUICID2)
class itkVectorContainerUICID3(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUICID3___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID3_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID3_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID3_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID3_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID3_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID3_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID3_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID3_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID3_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID3_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID3_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID3_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID3_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID3_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID3_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID3_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUICID3
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUICID3_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUICID3_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerUICID3 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUICID3_swigregister(itkVectorContainerUICID3)
class itkVectorContainerUIUC(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUIUC___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUC_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUC_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUC_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUC_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUC_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUC_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUC_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUC_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUC_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUC_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUC_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUC_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUC_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUC_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUC_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUC_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUIUC
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUIUC_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUC_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerUIUC in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUIUC_swigregister(itkVectorContainerUIUC)
class itkVectorContainerUIUI(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUIUI___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUI_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUI_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUI_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUI_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUI_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUI_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUI_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUI_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUI_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUI_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUI_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUI_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUI_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUI_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUI_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUI_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUIUI
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUIUI_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUI_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerUIUI in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUIUI_swigregister(itkVectorContainerUIUI)
class itkVectorContainerUIUL(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUIUL___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUL_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUL_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUL_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUL_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUL_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUL_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUL_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUL_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUL_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUL_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUL_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUL_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUL_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUL_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUL_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUL_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUIUL
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUIUL_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIUL_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerUIUL in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUIUL_swigregister(itkVectorContainerUIUL)
class itkVectorContainerUIVUC1(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUIVUC1___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIVUC1_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIVUC1_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIVUC1_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIVUC1_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIVUC1_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIVUC1_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIVUC1_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIVUC1_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIVUC1_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIVUC1_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIVUC1_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIVUC1_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIVUC1_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIVUC1_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIVUC1_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIVUC1_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerUIVUC1
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerUIVUC1_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerUIVUC1_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerUIVUC1 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerUIVUC1_swigregister(itkVectorContainerUIVUC1)
class itkVectorContainerULD(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULD___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULD_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULD_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULD_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULD_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULD_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULD_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULD_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULD_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULD_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULD_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULD_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULD_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULD_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULD_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULD_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULD_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULD
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULD_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULD_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerULD in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULD_swigregister(itkVectorContainerULD)
class itkVectorContainerULF(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULF___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULF_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULF_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULF_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULF_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULF_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULF_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULF_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULF_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULF_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULF_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULF_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULF_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULF_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULF_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULF_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULF_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULF
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULF_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULF_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerULF in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULF_swigregister(itkVectorContainerULF)
class itkVectorContainerULMD22(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULMD22___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD22_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD22_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD22_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD22_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD22_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD22_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD22_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD22_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD22_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD22_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD22_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD22_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD22_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD22_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD22_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD22_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULMD22
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULMD22_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD22_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerULMD22 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULMD22_swigregister(itkVectorContainerULMD22)
class itkVectorContainerULMD33(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULMD33___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD33_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD33_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD33_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD33_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD33_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD33_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD33_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD33_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD33_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD33_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD33_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD33_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD33_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD33_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD33_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD33_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULMD33
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULMD33_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMD33_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerULMD33 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULMD33_swigregister(itkVectorContainerULMD33)
class itkVectorContainerULMF22(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULMF22___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF22_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF22_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF22_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF22_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF22_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF22_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF22_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF22_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF22_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF22_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF22_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF22_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF22_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF22_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF22_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF22_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULMF22
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULMF22_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF22_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerULMF22 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULMF22_swigregister(itkVectorContainerULMF22)
class itkVectorContainerULMF33(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULMF33___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF33_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF33_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF33_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF33_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF33_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF33_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF33_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF33_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF33_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF33_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF33_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF33_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF33_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF33_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF33_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF33_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULMF33
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULMF33_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULMF33_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerULMF33 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULMF33_swigregister(itkVectorContainerULMF33)
class itkVectorContainerULPD2(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULPD2___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD2_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD2_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD2_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD2_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD2_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD2_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD2_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD2_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD2_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD2_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD2_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD2_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD2_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD2_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD2_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD2_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULPD2
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULPD2_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD2_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerULPD2 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULPD2_swigregister(itkVectorContainerULPD2)
class itkVectorContainerULPD3(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULPD3___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD3_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD3_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD3_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD3_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD3_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD3_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD3_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD3_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD3_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD3_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD3_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD3_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD3_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD3_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD3_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD3_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULPD3
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULPD3_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPD3_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerULPD3 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULPD3_swigregister(itkVectorContainerULPD3)
class itkVectorContainerULPF2(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULPF2___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF2_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF2_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF2_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF2_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF2_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF2_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF2_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF2_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF2_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF2_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF2_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF2_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF2_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF2_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF2_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF2_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULPF2
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULPF2_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF2_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerULPF2 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULPF2_swigregister(itkVectorContainerULPF2)
class itkVectorContainerULPF3(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULPF3___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF3_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF3_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF3_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF3_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF3_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF3_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF3_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF3_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF3_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF3_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF3_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF3_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF3_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF3_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF3_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF3_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULPF3
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULPF3_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULPF3_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerULPF3 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULPF3_swigregister(itkVectorContainerULPF3)
class itkVectorContainerULSUL(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULSUL___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULSUL_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULSUL_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULSUL_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULSUL_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULSUL_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULSUL_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULSUL_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULSUL_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULSUL_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULSUL_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULSUL_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULSUL_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULSUL_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULSUL_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULSUL_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULSUL_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULSUL
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULSUL_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULSUL_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerULSUL in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULSUL_swigregister(itkVectorContainerULSUL)
class itkVectorContainerULUC(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULUC___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUC_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUC_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUC_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUC_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUC_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUC_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUC_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUC_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUC_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUC_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUC_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUC_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUC_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUC_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUC_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUC_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULUC
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULUC_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUC_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerULUC in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULUC_swigregister(itkVectorContainerULUC)
class itkVectorContainerULUI(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULUI___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUI_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUI_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUI_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUI_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUI_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUI_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUI_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUI_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUI_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUI_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUI_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUI_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUI_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUI_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUI_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUI_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULUI
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULUI_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUI_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerULUI in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULUI_swigregister(itkVectorContainerULUI)
class itkVectorContainerULUL(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULUL___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUL_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUL_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUL_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUL_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUL_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUL_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUL_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUL_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUL_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUL_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUL_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUL_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUL_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUL_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUL_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUL_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULUL
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULUL_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULUL_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerULUL in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULUL_swigregister(itkVectorContainerULUL)
class itkVectorContainerULVD2(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULVD2___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD2_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD2_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD2_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD2_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD2_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD2_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD2_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD2_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD2_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD2_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD2_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD2_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD2_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD2_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD2_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD2_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULVD2
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULVD2_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD2_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerULVD2 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULVD2_swigregister(itkVectorContainerULVD2)
class itkVectorContainerULVD3(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULVD3___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD3_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD3_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD3_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD3_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD3_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD3_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD3_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD3_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD3_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD3_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD3_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD3_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD3_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD3_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD3_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD3_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULVD3
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULVD3_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVD3_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerULVD3 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULVD3_swigregister(itkVectorContainerULVD3)
class itkVectorContainerULVF2(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULVF2___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF2_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF2_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF2_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF2_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF2_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF2_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF2_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF2_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF2_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF2_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF2_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF2_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF2_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF2_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF2_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF2_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULVF2
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULVF2_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF2_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerULVF2 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULVF2_swigregister(itkVectorContainerULVF2)
class itkVectorContainerULVF3(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
    __New_orig__ = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULVF3___New_orig__)
    Clone = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF3_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF3_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF3_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF3_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF3_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF3_GetElement)
    SetElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF3_SetElement)
    InsertElement = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF3_InsertElement)
    IndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF3_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF3_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF3_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF3_DeleteIndex)
    Size = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF3_Size)
    Reserve = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF3_Reserve)
    Squeeze = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF3_Squeeze)
    Initialize = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF3_Initialize)
    __swig_destroy__ = _itkVectorContainerPython.delete_itkVectorContainerULVF3
    cast = _swig_new_static_method(_itkVectorContainerPython.itkVectorContainerULVF3_cast)
    GetPointer = _swig_new_instance_method(_itkVectorContainerPython.itkVectorContainerULVF3_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVectorContainerULVF3 in _itkVectorContainerPython:
_itkVectorContainerPython.itkVectorContainerULVF3_swigregister(itkVectorContainerULVF3)

