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

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

_swig_new_instance_method = _itkImagePython.SWIG_PyInstanceMethod_New
_swig_new_static_method = _itkImagePython.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 itkVectorPython
import itkFixedArrayPython
import pyBasePython
import vnl_vector_refPython
import stdcomplexPython
import vnl_vectorPython
import vnl_matrixPython
import itkOffsetPython
import itkSizePython
import ITKCommonBasePython
import itkRGBAPixelPython
import itkImageRegionPython
import itkIndexPython
import itkPointPython
import itkRGBPixelPython
import itkSymmetricSecondRankTensorPython
import itkMatrixPython
import vnl_matrix_fixedPython
import itkCovariantVectorPython

def itkImageCVD43_New():
  return itkImageCVD43.New()


def itkImageCVD33_New():
  return itkImageCVD33.New()


def itkImageCVD23_New():
  return itkImageCVD23.New()


def itkImageCVD42_New():
  return itkImageCVD42.New()


def itkImageCVD32_New():
  return itkImageCVD32.New()


def itkImageCVD22_New():
  return itkImageCVD22.New()


def itkImageVF13_New():
  return itkImageVF13.New()


def itkImageVD44_New():
  return itkImageVD44.New()


def itkImageVD34_New():
  return itkImageVD34.New()


def itkImageVD24_New():
  return itkImageVD24.New()


def itkImageVF12_New():
  return itkImageVF12.New()


def itkImageSSRTD33_New():
  return itkImageSSRTD33.New()


def itkImageO33_New():
  return itkImageO33.New()


def itkImageFAF33_New():
  return itkImageFAF33.New()


def itkImageB3_New():
  return itkImageB3.New()


def itkImageVD43_New():
  return itkImageVD43.New()


def itkImageVD33_New():
  return itkImageVD33.New()


def itkImageVD23_New():
  return itkImageVD23.New()


def itkImageULL3_New():
  return itkImageULL3.New()


def itkImageUL3_New():
  return itkImageUL3.New()


def itkImageD3_New():
  return itkImageD3.New()


def itkImageCF3_New():
  return itkImageCF3.New()


def itkImageF3_New():
  return itkImageF3.New()


def itkImageUC3_New():
  return itkImageUC3.New()


def itkImageSS3_New():
  return itkImageSS3.New()


def itkImageCVF43_New():
  return itkImageCVF43.New()


def itkImageCVF33_New():
  return itkImageCVF33.New()


def itkImageCVF23_New():
  return itkImageCVF23.New()


def itkImageVF43_New():
  return itkImageVF43.New()


def itkImageVF33_New():
  return itkImageVF33.New()


def itkImageVF23_New():
  return itkImageVF23.New()


def itkImageRGBAUC3_New():
  return itkImageRGBAUC3.New()


def itkImageRGBUC3_New():
  return itkImageRGBUC3.New()


def itkImageSSRTD22_New():
  return itkImageSSRTD22.New()


def itkImageO22_New():
  return itkImageO22.New()


def itkImageFAF22_New():
  return itkImageFAF22.New()


def itkImageB2_New():
  return itkImageB2.New()


def itkImageVD42_New():
  return itkImageVD42.New()


def itkImageVD32_New():
  return itkImageVD32.New()


def itkImageVD22_New():
  return itkImageVD22.New()


def itkImageULL2_New():
  return itkImageULL2.New()


def itkImageUL2_New():
  return itkImageUL2.New()


def itkImageD2_New():
  return itkImageD2.New()


def itkImageCF2_New():
  return itkImageCF2.New()


def itkImageF2_New():
  return itkImageF2.New()


def itkImageUC2_New():
  return itkImageUC2.New()


def itkImageSS2_New():
  return itkImageSS2.New()


def itkImageCVF42_New():
  return itkImageCVF42.New()


def itkImageCVF32_New():
  return itkImageCVF32.New()


def itkImageCVF22_New():
  return itkImageCVF22.New()


def itkImageVF42_New():
  return itkImageVF42.New()


def itkImageVF32_New():
  return itkImageVF32.New()


def itkImageVF22_New():
  return itkImageVF22.New()


def itkImageRGBAUC2_New():
  return itkImageRGBAUC2.New()


def itkImageRGBUC2_New():
  return itkImageRGBUC2.New()


def itkImageBase4_New():
  return itkImageBase4.New()


def itkImageBase3_New():
  return itkImageBase3.New()


def itkImageBase2_New():
  return itkImageBase2.New()

class itkImageBase2(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkImageBase2 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(_itkImagePython.itkImageBase2___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageBase2_Clone)
    GetImageDimension = _swig_new_static_method(_itkImagePython.itkImageBase2_GetImageDimension)
    SetOrigin = _swig_new_instance_method(_itkImagePython.itkImageBase2_SetOrigin)
    SetDirection = _swig_new_instance_method(_itkImagePython.itkImageBase2_SetDirection)
    GetDirection = _swig_new_instance_method(_itkImagePython.itkImageBase2_GetDirection)
    GetInverseDirection = _swig_new_instance_method(_itkImagePython.itkImageBase2_GetInverseDirection)
    GetSpacing = _swig_new_instance_method(_itkImagePython.itkImageBase2_GetSpacing)
    GetOrigin = _swig_new_instance_method(_itkImagePython.itkImageBase2_GetOrigin)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageBase2_Allocate)
    SetLargestPossibleRegion = _swig_new_instance_method(_itkImagePython.itkImageBase2_SetLargestPossibleRegion)
    GetLargestPossibleRegion = _swig_new_instance_method(_itkImagePython.itkImageBase2_GetLargestPossibleRegion)
    SetBufferedRegion = _swig_new_instance_method(_itkImagePython.itkImageBase2_SetBufferedRegion)
    GetBufferedRegion = _swig_new_instance_method(_itkImagePython.itkImageBase2_GetBufferedRegion)
    SetRequestedRegion = _swig_new_instance_method(_itkImagePython.itkImageBase2_SetRequestedRegion)
    GetRequestedRegion = _swig_new_instance_method(_itkImagePython.itkImageBase2_GetRequestedRegion)
    SetRegions = _swig_new_instance_method(_itkImagePython.itkImageBase2_SetRegions)
    GetOffsetTable = _swig_new_instance_method(_itkImagePython.itkImageBase2_GetOffsetTable)
    ComputeOffset = _swig_new_instance_method(_itkImagePython.itkImageBase2_ComputeOffset)
    ComputeIndex = _swig_new_instance_method(_itkImagePython.itkImageBase2_ComputeIndex)
    SetSpacing = _swig_new_instance_method(_itkImagePython.itkImageBase2_SetSpacing)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageBase2_Graft)
    GetNumberOfComponentsPerPixel = _swig_new_instance_method(_itkImagePython.itkImageBase2_GetNumberOfComponentsPerPixel)
    SetNumberOfComponentsPerPixel = _swig_new_instance_method(_itkImagePython.itkImageBase2_SetNumberOfComponentsPerPixel)
    __swig_destroy__ = _itkImagePython.delete_itkImageBase2
    cast = _swig_new_static_method(_itkImagePython.itkImageBase2_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageBase2_GetPointer)

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

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

          itkImageBase2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageBase2.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageBase2.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)

    TransformPhysicalPointToIndex = _swig_new_instance_method(_itkImagePython.itkImageBase2_TransformPhysicalPointToIndex)
    TransformPhysicalPointToContinuousIndex = _swig_new_instance_method(_itkImagePython.itkImageBase2_TransformPhysicalPointToContinuousIndex)
    TransformContinuousIndexToPhysicalPoint = _swig_new_instance_method(_itkImagePython.itkImageBase2_TransformContinuousIndexToPhysicalPoint)
    TransformIndexToPhysicalPoint = _swig_new_instance_method(_itkImagePython.itkImageBase2_TransformIndexToPhysicalPoint)

# Register itkImageBase2 in _itkImagePython:
_itkImagePython.itkImageBase2_swigregister(itkImageBase2)
class itkImageBase3(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkImageBase3 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(_itkImagePython.itkImageBase3___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageBase3_Clone)
    GetImageDimension = _swig_new_static_method(_itkImagePython.itkImageBase3_GetImageDimension)
    SetOrigin = _swig_new_instance_method(_itkImagePython.itkImageBase3_SetOrigin)
    SetDirection = _swig_new_instance_method(_itkImagePython.itkImageBase3_SetDirection)
    GetDirection = _swig_new_instance_method(_itkImagePython.itkImageBase3_GetDirection)
    GetInverseDirection = _swig_new_instance_method(_itkImagePython.itkImageBase3_GetInverseDirection)
    GetSpacing = _swig_new_instance_method(_itkImagePython.itkImageBase3_GetSpacing)
    GetOrigin = _swig_new_instance_method(_itkImagePython.itkImageBase3_GetOrigin)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageBase3_Allocate)
    SetLargestPossibleRegion = _swig_new_instance_method(_itkImagePython.itkImageBase3_SetLargestPossibleRegion)
    GetLargestPossibleRegion = _swig_new_instance_method(_itkImagePython.itkImageBase3_GetLargestPossibleRegion)
    SetBufferedRegion = _swig_new_instance_method(_itkImagePython.itkImageBase3_SetBufferedRegion)
    GetBufferedRegion = _swig_new_instance_method(_itkImagePython.itkImageBase3_GetBufferedRegion)
    SetRequestedRegion = _swig_new_instance_method(_itkImagePython.itkImageBase3_SetRequestedRegion)
    GetRequestedRegion = _swig_new_instance_method(_itkImagePython.itkImageBase3_GetRequestedRegion)
    SetRegions = _swig_new_instance_method(_itkImagePython.itkImageBase3_SetRegions)
    GetOffsetTable = _swig_new_instance_method(_itkImagePython.itkImageBase3_GetOffsetTable)
    ComputeOffset = _swig_new_instance_method(_itkImagePython.itkImageBase3_ComputeOffset)
    ComputeIndex = _swig_new_instance_method(_itkImagePython.itkImageBase3_ComputeIndex)
    SetSpacing = _swig_new_instance_method(_itkImagePython.itkImageBase3_SetSpacing)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageBase3_Graft)
    GetNumberOfComponentsPerPixel = _swig_new_instance_method(_itkImagePython.itkImageBase3_GetNumberOfComponentsPerPixel)
    SetNumberOfComponentsPerPixel = _swig_new_instance_method(_itkImagePython.itkImageBase3_SetNumberOfComponentsPerPixel)
    __swig_destroy__ = _itkImagePython.delete_itkImageBase3
    cast = _swig_new_static_method(_itkImagePython.itkImageBase3_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageBase3_GetPointer)

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

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

          itkImageBase3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageBase3.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageBase3.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)

    TransformPhysicalPointToIndex = _swig_new_instance_method(_itkImagePython.itkImageBase3_TransformPhysicalPointToIndex)
    TransformPhysicalPointToContinuousIndex = _swig_new_instance_method(_itkImagePython.itkImageBase3_TransformPhysicalPointToContinuousIndex)
    TransformContinuousIndexToPhysicalPoint = _swig_new_instance_method(_itkImagePython.itkImageBase3_TransformContinuousIndexToPhysicalPoint)
    TransformIndexToPhysicalPoint = _swig_new_instance_method(_itkImagePython.itkImageBase3_TransformIndexToPhysicalPoint)

# Register itkImageBase3 in _itkImagePython:
_itkImagePython.itkImageBase3_swigregister(itkImageBase3)
class itkImageBase4(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkImageBase4 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(_itkImagePython.itkImageBase4___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageBase4_Clone)
    GetImageDimension = _swig_new_static_method(_itkImagePython.itkImageBase4_GetImageDimension)
    SetOrigin = _swig_new_instance_method(_itkImagePython.itkImageBase4_SetOrigin)
    SetDirection = _swig_new_instance_method(_itkImagePython.itkImageBase4_SetDirection)
    GetDirection = _swig_new_instance_method(_itkImagePython.itkImageBase4_GetDirection)
    GetInverseDirection = _swig_new_instance_method(_itkImagePython.itkImageBase4_GetInverseDirection)
    GetSpacing = _swig_new_instance_method(_itkImagePython.itkImageBase4_GetSpacing)
    GetOrigin = _swig_new_instance_method(_itkImagePython.itkImageBase4_GetOrigin)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageBase4_Allocate)
    SetLargestPossibleRegion = _swig_new_instance_method(_itkImagePython.itkImageBase4_SetLargestPossibleRegion)
    GetLargestPossibleRegion = _swig_new_instance_method(_itkImagePython.itkImageBase4_GetLargestPossibleRegion)
    SetBufferedRegion = _swig_new_instance_method(_itkImagePython.itkImageBase4_SetBufferedRegion)
    GetBufferedRegion = _swig_new_instance_method(_itkImagePython.itkImageBase4_GetBufferedRegion)
    SetRequestedRegion = _swig_new_instance_method(_itkImagePython.itkImageBase4_SetRequestedRegion)
    GetRequestedRegion = _swig_new_instance_method(_itkImagePython.itkImageBase4_GetRequestedRegion)
    SetRegions = _swig_new_instance_method(_itkImagePython.itkImageBase4_SetRegions)
    GetOffsetTable = _swig_new_instance_method(_itkImagePython.itkImageBase4_GetOffsetTable)
    ComputeOffset = _swig_new_instance_method(_itkImagePython.itkImageBase4_ComputeOffset)
    ComputeIndex = _swig_new_instance_method(_itkImagePython.itkImageBase4_ComputeIndex)
    SetSpacing = _swig_new_instance_method(_itkImagePython.itkImageBase4_SetSpacing)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageBase4_Graft)
    GetNumberOfComponentsPerPixel = _swig_new_instance_method(_itkImagePython.itkImageBase4_GetNumberOfComponentsPerPixel)
    SetNumberOfComponentsPerPixel = _swig_new_instance_method(_itkImagePython.itkImageBase4_SetNumberOfComponentsPerPixel)
    __swig_destroy__ = _itkImagePython.delete_itkImageBase4
    cast = _swig_new_static_method(_itkImagePython.itkImageBase4_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageBase4_GetPointer)

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

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

          itkImageBase4.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageBase4.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageBase4.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)

    TransformPhysicalPointToIndex = _swig_new_instance_method(_itkImagePython.itkImageBase4_TransformPhysicalPointToIndex)
    TransformPhysicalPointToContinuousIndex = _swig_new_instance_method(_itkImagePython.itkImageBase4_TransformPhysicalPointToContinuousIndex)
    TransformContinuousIndexToPhysicalPoint = _swig_new_instance_method(_itkImagePython.itkImageBase4_TransformContinuousIndexToPhysicalPoint)
    TransformIndexToPhysicalPoint = _swig_new_instance_method(_itkImagePython.itkImageBase4_TransformIndexToPhysicalPoint)

# Register itkImageBase4 in _itkImagePython:
_itkImagePython.itkImageBase4_swigregister(itkImageBase4)
class itkImageCF2(itkImageBase2):
    r"""Proxy of C++ itkImageCF2 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(_itkImagePython.itkImageCF2___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageCF2_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageCF2_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageCF2_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageCF2_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageCF2_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageCF2_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCF2_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCF2_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageCF2_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageCF2_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageCF2_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageCF2
    cast = _swig_new_static_method(_itkImagePython.itkImageCF2_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageCF2_GetPointer)

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

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

          itkImageCF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageCF2.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageCF2.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageCF2 in _itkImagePython:
_itkImagePython.itkImageCF2_swigregister(itkImageCF2)
class itkImageCF3(itkImageBase3):
    r"""Proxy of C++ itkImageCF3 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(_itkImagePython.itkImageCF3___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageCF3_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageCF3_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageCF3_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageCF3_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageCF3_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageCF3_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCF3_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCF3_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageCF3_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageCF3_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageCF3_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageCF3
    cast = _swig_new_static_method(_itkImagePython.itkImageCF3_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageCF3_GetPointer)

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

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

          itkImageCF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageCF3.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageCF3.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageCF3 in _itkImagePython:
_itkImagePython.itkImageCF3_swigregister(itkImageCF3)
class itkImageCVD22(itkImageBase2):
    r"""Proxy of C++ itkImageCVD22 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(_itkImagePython.itkImageCVD22___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageCVD22_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageCVD22_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageCVD22_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageCVD22_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageCVD22_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageCVD22_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCVD22_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCVD22_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageCVD22_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageCVD22_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageCVD22_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageCVD22
    cast = _swig_new_static_method(_itkImagePython.itkImageCVD22_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageCVD22_GetPointer)

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

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

          itkImageCVD22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageCVD22.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageCVD22.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageCVD22 in _itkImagePython:
_itkImagePython.itkImageCVD22_swigregister(itkImageCVD22)
class itkImageCVD23(itkImageBase3):
    r"""Proxy of C++ itkImageCVD23 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(_itkImagePython.itkImageCVD23___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageCVD23_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageCVD23_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageCVD23_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageCVD23_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageCVD23_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageCVD23_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCVD23_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCVD23_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageCVD23_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageCVD23_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageCVD23_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageCVD23
    cast = _swig_new_static_method(_itkImagePython.itkImageCVD23_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageCVD23_GetPointer)

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

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

          itkImageCVD23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageCVD23.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageCVD23.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageCVD23 in _itkImagePython:
_itkImagePython.itkImageCVD23_swigregister(itkImageCVD23)
class itkImageCVD32(itkImageBase2):
    r"""Proxy of C++ itkImageCVD32 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(_itkImagePython.itkImageCVD32___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageCVD32_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageCVD32_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageCVD32_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageCVD32_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageCVD32_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageCVD32_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCVD32_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCVD32_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageCVD32_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageCVD32_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageCVD32_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageCVD32
    cast = _swig_new_static_method(_itkImagePython.itkImageCVD32_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageCVD32_GetPointer)

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

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

          itkImageCVD32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageCVD32.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageCVD32.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageCVD32 in _itkImagePython:
_itkImagePython.itkImageCVD32_swigregister(itkImageCVD32)
class itkImageCVD33(itkImageBase3):
    r"""Proxy of C++ itkImageCVD33 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(_itkImagePython.itkImageCVD33___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageCVD33_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageCVD33_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageCVD33_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageCVD33_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageCVD33_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageCVD33_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCVD33_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCVD33_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageCVD33_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageCVD33_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageCVD33_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageCVD33
    cast = _swig_new_static_method(_itkImagePython.itkImageCVD33_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageCVD33_GetPointer)

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

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

          itkImageCVD33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageCVD33.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageCVD33.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageCVD33 in _itkImagePython:
_itkImagePython.itkImageCVD33_swigregister(itkImageCVD33)
class itkImageCVD42(itkImageBase2):
    r"""Proxy of C++ itkImageCVD42 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(_itkImagePython.itkImageCVD42___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageCVD42_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageCVD42_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageCVD42_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageCVD42_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageCVD42_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageCVD42_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCVD42_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCVD42_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageCVD42_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageCVD42_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageCVD42_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageCVD42
    cast = _swig_new_static_method(_itkImagePython.itkImageCVD42_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageCVD42_GetPointer)

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

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

          itkImageCVD42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageCVD42.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageCVD42.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageCVD42 in _itkImagePython:
_itkImagePython.itkImageCVD42_swigregister(itkImageCVD42)
class itkImageCVD43(itkImageBase3):
    r"""Proxy of C++ itkImageCVD43 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(_itkImagePython.itkImageCVD43___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageCVD43_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageCVD43_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageCVD43_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageCVD43_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageCVD43_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageCVD43_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCVD43_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCVD43_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageCVD43_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageCVD43_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageCVD43_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageCVD43
    cast = _swig_new_static_method(_itkImagePython.itkImageCVD43_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageCVD43_GetPointer)

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

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

          itkImageCVD43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageCVD43.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageCVD43.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageCVD43 in _itkImagePython:
_itkImagePython.itkImageCVD43_swigregister(itkImageCVD43)
class itkImageCVF22(itkImageBase2):
    r"""Proxy of C++ itkImageCVF22 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(_itkImagePython.itkImageCVF22___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageCVF22_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageCVF22_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageCVF22_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageCVF22_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageCVF22_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageCVF22_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCVF22_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCVF22_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageCVF22_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageCVF22_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageCVF22_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageCVF22
    cast = _swig_new_static_method(_itkImagePython.itkImageCVF22_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageCVF22_GetPointer)

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

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

          itkImageCVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageCVF22.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageCVF22.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageCVF22 in _itkImagePython:
_itkImagePython.itkImageCVF22_swigregister(itkImageCVF22)
class itkImageCVF23(itkImageBase3):
    r"""Proxy of C++ itkImageCVF23 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(_itkImagePython.itkImageCVF23___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageCVF23_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageCVF23_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageCVF23_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageCVF23_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageCVF23_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageCVF23_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCVF23_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCVF23_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageCVF23_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageCVF23_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageCVF23_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageCVF23
    cast = _swig_new_static_method(_itkImagePython.itkImageCVF23_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageCVF23_GetPointer)

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

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

          itkImageCVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageCVF23.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageCVF23.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageCVF23 in _itkImagePython:
_itkImagePython.itkImageCVF23_swigregister(itkImageCVF23)
class itkImageCVF32(itkImageBase2):
    r"""Proxy of C++ itkImageCVF32 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(_itkImagePython.itkImageCVF32___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageCVF32_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageCVF32_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageCVF32_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageCVF32_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageCVF32_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageCVF32_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCVF32_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCVF32_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageCVF32_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageCVF32_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageCVF32_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageCVF32
    cast = _swig_new_static_method(_itkImagePython.itkImageCVF32_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageCVF32_GetPointer)

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

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

          itkImageCVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageCVF32.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageCVF32.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageCVF32 in _itkImagePython:
_itkImagePython.itkImageCVF32_swigregister(itkImageCVF32)
class itkImageCVF33(itkImageBase3):
    r"""Proxy of C++ itkImageCVF33 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(_itkImagePython.itkImageCVF33___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageCVF33_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageCVF33_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageCVF33_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageCVF33_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageCVF33_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageCVF33_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCVF33_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCVF33_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageCVF33_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageCVF33_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageCVF33_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageCVF33
    cast = _swig_new_static_method(_itkImagePython.itkImageCVF33_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageCVF33_GetPointer)

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

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

          itkImageCVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageCVF33.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageCVF33.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageCVF33 in _itkImagePython:
_itkImagePython.itkImageCVF33_swigregister(itkImageCVF33)
class itkImageCVF42(itkImageBase2):
    r"""Proxy of C++ itkImageCVF42 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(_itkImagePython.itkImageCVF42___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageCVF42_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageCVF42_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageCVF42_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageCVF42_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageCVF42_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageCVF42_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCVF42_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCVF42_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageCVF42_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageCVF42_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageCVF42_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageCVF42
    cast = _swig_new_static_method(_itkImagePython.itkImageCVF42_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageCVF42_GetPointer)

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

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

          itkImageCVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageCVF42.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageCVF42.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageCVF42 in _itkImagePython:
_itkImagePython.itkImageCVF42_swigregister(itkImageCVF42)
class itkImageCVF43(itkImageBase3):
    r"""Proxy of C++ itkImageCVF43 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(_itkImagePython.itkImageCVF43___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageCVF43_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageCVF43_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageCVF43_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageCVF43_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageCVF43_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageCVF43_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCVF43_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageCVF43_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageCVF43_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageCVF43_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageCVF43_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageCVF43
    cast = _swig_new_static_method(_itkImagePython.itkImageCVF43_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageCVF43_GetPointer)

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

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

          itkImageCVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageCVF43.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageCVF43.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageCVF43 in _itkImagePython:
_itkImagePython.itkImageCVF43_swigregister(itkImageCVF43)
class itkImageD2(itkImageBase2):
    r"""Proxy of C++ itkImageD2 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(_itkImagePython.itkImageD2___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageD2_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageD2_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageD2_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageD2_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageD2_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageD2_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageD2_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageD2_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageD2_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageD2_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageD2_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageD2
    cast = _swig_new_static_method(_itkImagePython.itkImageD2_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageD2_GetPointer)

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

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

          itkImageD2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageD2.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageD2.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageD2 in _itkImagePython:
_itkImagePython.itkImageD2_swigregister(itkImageD2)
class itkImageD3(itkImageBase3):
    r"""Proxy of C++ itkImageD3 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(_itkImagePython.itkImageD3___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageD3_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageD3_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageD3_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageD3_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageD3_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageD3_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageD3_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageD3_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageD3_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageD3_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageD3_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageD3
    cast = _swig_new_static_method(_itkImagePython.itkImageD3_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageD3_GetPointer)

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

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

          itkImageD3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageD3.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageD3.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageD3 in _itkImagePython:
_itkImagePython.itkImageD3_swigregister(itkImageD3)
class itkImageF2(itkImageBase2):
    r"""Proxy of C++ itkImageF2 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(_itkImagePython.itkImageF2___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageF2_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageF2_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageF2_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageF2_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageF2_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageF2_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageF2_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageF2_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageF2_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageF2_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageF2_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageF2
    cast = _swig_new_static_method(_itkImagePython.itkImageF2_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageF2_GetPointer)

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

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

          itkImageF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageF2.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageF2.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageF2 in _itkImagePython:
_itkImagePython.itkImageF2_swigregister(itkImageF2)
class itkImageF3(itkImageBase3):
    r"""Proxy of C++ itkImageF3 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(_itkImagePython.itkImageF3___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageF3_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageF3_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageF3_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageF3_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageF3_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageF3_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageF3_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageF3_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageF3_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageF3_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageF3_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageF3
    cast = _swig_new_static_method(_itkImagePython.itkImageF3_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageF3_GetPointer)

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

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

          itkImageF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageF3.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageF3.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageF3 in _itkImagePython:
_itkImagePython.itkImageF3_swigregister(itkImageF3)
class itkImageFAF22(itkImageBase2):
    r"""Proxy of C++ itkImageFAF22 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(_itkImagePython.itkImageFAF22___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageFAF22_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageFAF22_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageFAF22_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageFAF22_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageFAF22_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageFAF22_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageFAF22_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageFAF22_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageFAF22_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageFAF22_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageFAF22_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageFAF22
    cast = _swig_new_static_method(_itkImagePython.itkImageFAF22_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageFAF22_GetPointer)

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

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

          itkImageFAF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageFAF22.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageFAF22.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageFAF22 in _itkImagePython:
_itkImagePython.itkImageFAF22_swigregister(itkImageFAF22)
class itkImageFAF33(itkImageBase3):
    r"""Proxy of C++ itkImageFAF33 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(_itkImagePython.itkImageFAF33___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageFAF33_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageFAF33_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageFAF33_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageFAF33_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageFAF33_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageFAF33_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageFAF33_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageFAF33_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageFAF33_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageFAF33_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageFAF33_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageFAF33
    cast = _swig_new_static_method(_itkImagePython.itkImageFAF33_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageFAF33_GetPointer)

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

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

          itkImageFAF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageFAF33.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageFAF33.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageFAF33 in _itkImagePython:
_itkImagePython.itkImageFAF33_swigregister(itkImageFAF33)
class itkImageO22(itkImageBase2):
    r"""Proxy of C++ itkImageO22 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(_itkImagePython.itkImageO22___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageO22_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageO22_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageO22_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageO22_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageO22_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageO22_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageO22_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageO22_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageO22_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageO22_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageO22_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageO22
    cast = _swig_new_static_method(_itkImagePython.itkImageO22_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageO22_GetPointer)

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

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

          itkImageO22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageO22.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageO22.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageO22 in _itkImagePython:
_itkImagePython.itkImageO22_swigregister(itkImageO22)
class itkImageO33(itkImageBase3):
    r"""Proxy of C++ itkImageO33 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(_itkImagePython.itkImageO33___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageO33_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageO33_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageO33_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageO33_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageO33_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageO33_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageO33_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageO33_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageO33_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageO33_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageO33_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageO33
    cast = _swig_new_static_method(_itkImagePython.itkImageO33_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageO33_GetPointer)

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

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

          itkImageO33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageO33.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageO33.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageO33 in _itkImagePython:
_itkImagePython.itkImageO33_swigregister(itkImageO33)
class itkImageRGBAUC2(itkImageBase2):
    r"""Proxy of C++ itkImageRGBAUC2 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(_itkImagePython.itkImageRGBAUC2___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageRGBAUC2_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageRGBAUC2_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageRGBAUC2_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageRGBAUC2_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageRGBAUC2_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageRGBAUC2_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageRGBAUC2_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageRGBAUC2_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageRGBAUC2_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageRGBAUC2_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageRGBAUC2_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageRGBAUC2
    cast = _swig_new_static_method(_itkImagePython.itkImageRGBAUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageRGBAUC2_GetPointer)

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

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

          itkImageRGBAUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageRGBAUC2.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageRGBAUC2.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageRGBAUC2 in _itkImagePython:
_itkImagePython.itkImageRGBAUC2_swigregister(itkImageRGBAUC2)
class itkImageRGBAUC3(itkImageBase3):
    r"""Proxy of C++ itkImageRGBAUC3 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(_itkImagePython.itkImageRGBAUC3___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageRGBAUC3_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageRGBAUC3_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageRGBAUC3_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageRGBAUC3_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageRGBAUC3_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageRGBAUC3_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageRGBAUC3_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageRGBAUC3_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageRGBAUC3_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageRGBAUC3_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageRGBAUC3_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageRGBAUC3
    cast = _swig_new_static_method(_itkImagePython.itkImageRGBAUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageRGBAUC3_GetPointer)

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

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

          itkImageRGBAUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageRGBAUC3.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageRGBAUC3.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageRGBAUC3 in _itkImagePython:
_itkImagePython.itkImageRGBAUC3_swigregister(itkImageRGBAUC3)
class itkImageRGBUC2(itkImageBase2):
    r"""Proxy of C++ itkImageRGBUC2 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(_itkImagePython.itkImageRGBUC2___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageRGBUC2_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageRGBUC2_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageRGBUC2_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageRGBUC2_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageRGBUC2_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageRGBUC2_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageRGBUC2_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageRGBUC2_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageRGBUC2_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageRGBUC2_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageRGBUC2_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageRGBUC2
    cast = _swig_new_static_method(_itkImagePython.itkImageRGBUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageRGBUC2_GetPointer)

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

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

          itkImageRGBUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageRGBUC2.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageRGBUC2.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageRGBUC2 in _itkImagePython:
_itkImagePython.itkImageRGBUC2_swigregister(itkImageRGBUC2)
class itkImageRGBUC3(itkImageBase3):
    r"""Proxy of C++ itkImageRGBUC3 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(_itkImagePython.itkImageRGBUC3___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageRGBUC3_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageRGBUC3_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageRGBUC3_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageRGBUC3_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageRGBUC3_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageRGBUC3_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageRGBUC3_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageRGBUC3_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageRGBUC3_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageRGBUC3_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageRGBUC3_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageRGBUC3
    cast = _swig_new_static_method(_itkImagePython.itkImageRGBUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageRGBUC3_GetPointer)

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

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

          itkImageRGBUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageRGBUC3.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageRGBUC3.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageRGBUC3 in _itkImagePython:
_itkImagePython.itkImageRGBUC3_swigregister(itkImageRGBUC3)
class itkImageSS2(itkImageBase2):
    r"""Proxy of C++ itkImageSS2 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(_itkImagePython.itkImageSS2___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageSS2_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageSS2_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageSS2_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageSS2_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageSS2_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageSS2_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageSS2_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageSS2_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageSS2_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageSS2_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageSS2_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageSS2
    cast = _swig_new_static_method(_itkImagePython.itkImageSS2_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageSS2_GetPointer)

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

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

          itkImageSS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageSS2.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageSS2.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageSS2 in _itkImagePython:
_itkImagePython.itkImageSS2_swigregister(itkImageSS2)
class itkImageSS3(itkImageBase3):
    r"""Proxy of C++ itkImageSS3 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(_itkImagePython.itkImageSS3___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageSS3_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageSS3_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageSS3_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageSS3_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageSS3_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageSS3_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageSS3_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageSS3_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageSS3_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageSS3_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageSS3_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageSS3
    cast = _swig_new_static_method(_itkImagePython.itkImageSS3_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageSS3_GetPointer)

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

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

          itkImageSS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageSS3.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageSS3.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageSS3 in _itkImagePython:
_itkImagePython.itkImageSS3_swigregister(itkImageSS3)
class itkImageSSRTD22(itkImageBase2):
    r"""Proxy of C++ itkImageSSRTD22 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(_itkImagePython.itkImageSSRTD22___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageSSRTD22_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageSSRTD22_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageSSRTD22_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageSSRTD22_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageSSRTD22_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageSSRTD22_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageSSRTD22_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageSSRTD22_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageSSRTD22_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageSSRTD22_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageSSRTD22_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageSSRTD22
    cast = _swig_new_static_method(_itkImagePython.itkImageSSRTD22_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageSSRTD22_GetPointer)

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

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

          itkImageSSRTD22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageSSRTD22.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageSSRTD22.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageSSRTD22 in _itkImagePython:
_itkImagePython.itkImageSSRTD22_swigregister(itkImageSSRTD22)
class itkImageSSRTD33(itkImageBase3):
    r"""Proxy of C++ itkImageSSRTD33 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(_itkImagePython.itkImageSSRTD33___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageSSRTD33_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageSSRTD33_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageSSRTD33_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageSSRTD33_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageSSRTD33_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageSSRTD33_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageSSRTD33_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageSSRTD33_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageSSRTD33_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageSSRTD33_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageSSRTD33_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageSSRTD33
    cast = _swig_new_static_method(_itkImagePython.itkImageSSRTD33_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageSSRTD33_GetPointer)

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

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

          itkImageSSRTD33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageSSRTD33.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageSSRTD33.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageSSRTD33 in _itkImagePython:
_itkImagePython.itkImageSSRTD33_swigregister(itkImageSSRTD33)
class itkImageUC2(itkImageBase2):
    r"""Proxy of C++ itkImageUC2 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(_itkImagePython.itkImageUC2___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageUC2_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageUC2_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageUC2_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageUC2_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageUC2_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageUC2_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageUC2_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageUC2_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageUC2_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageUC2_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageUC2_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageUC2
    cast = _swig_new_static_method(_itkImagePython.itkImageUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageUC2_GetPointer)

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

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

          itkImageUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageUC2.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageUC2.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageUC2 in _itkImagePython:
_itkImagePython.itkImageUC2_swigregister(itkImageUC2)
class itkImageUC3(itkImageBase3):
    r"""Proxy of C++ itkImageUC3 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(_itkImagePython.itkImageUC3___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageUC3_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageUC3_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageUC3_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageUC3_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageUC3_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageUC3_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageUC3_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageUC3_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageUC3_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageUC3_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageUC3_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageUC3
    cast = _swig_new_static_method(_itkImagePython.itkImageUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageUC3_GetPointer)

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

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

          itkImageUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageUC3.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageUC3.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageUC3 in _itkImagePython:
_itkImagePython.itkImageUC3_swigregister(itkImageUC3)
class itkImageUL2(itkImageBase2):
    r"""Proxy of C++ itkImageUL2 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(_itkImagePython.itkImageUL2___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageUL2_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageUL2_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageUL2_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageUL2_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageUL2_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageUL2_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageUL2_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageUL2_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageUL2_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageUL2_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageUL2_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageUL2
    cast = _swig_new_static_method(_itkImagePython.itkImageUL2_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageUL2_GetPointer)

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

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

          itkImageUL2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageUL2.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageUL2.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageUL2 in _itkImagePython:
_itkImagePython.itkImageUL2_swigregister(itkImageUL2)
class itkImageUL3(itkImageBase3):
    r"""Proxy of C++ itkImageUL3 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(_itkImagePython.itkImageUL3___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageUL3_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageUL3_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageUL3_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageUL3_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageUL3_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageUL3_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageUL3_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageUL3_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageUL3_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageUL3_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageUL3_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageUL3
    cast = _swig_new_static_method(_itkImagePython.itkImageUL3_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageUL3_GetPointer)

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

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

          itkImageUL3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageUL3.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageUL3.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageUL3 in _itkImagePython:
_itkImagePython.itkImageUL3_swigregister(itkImageUL3)
class itkImageULL2(itkImageBase2):
    r"""Proxy of C++ itkImageULL2 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(_itkImagePython.itkImageULL2___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageULL2_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageULL2_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageULL2_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageULL2_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageULL2_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageULL2_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageULL2_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageULL2_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageULL2_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageULL2_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageULL2_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageULL2
    cast = _swig_new_static_method(_itkImagePython.itkImageULL2_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageULL2_GetPointer)

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

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

          itkImageULL2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageULL2.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageULL2.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageULL2 in _itkImagePython:
_itkImagePython.itkImageULL2_swigregister(itkImageULL2)
class itkImageULL3(itkImageBase3):
    r"""Proxy of C++ itkImageULL3 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(_itkImagePython.itkImageULL3___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageULL3_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageULL3_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageULL3_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageULL3_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageULL3_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageULL3_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageULL3_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageULL3_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageULL3_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageULL3_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageULL3_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageULL3
    cast = _swig_new_static_method(_itkImagePython.itkImageULL3_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageULL3_GetPointer)

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

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

          itkImageULL3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageULL3.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageULL3.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageULL3 in _itkImagePython:
_itkImagePython.itkImageULL3_swigregister(itkImageULL3)
class itkImageVD22(itkImageBase2):
    r"""Proxy of C++ itkImageVD22 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(_itkImagePython.itkImageVD22___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageVD22_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageVD22_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageVD22_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageVD22_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageVD22_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageVD22_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVD22_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVD22_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageVD22_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageVD22_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageVD22_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageVD22
    cast = _swig_new_static_method(_itkImagePython.itkImageVD22_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageVD22_GetPointer)

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

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

          itkImageVD22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageVD22.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageVD22.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageVD22 in _itkImagePython:
_itkImagePython.itkImageVD22_swigregister(itkImageVD22)
class itkImageVD23(itkImageBase3):
    r"""Proxy of C++ itkImageVD23 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(_itkImagePython.itkImageVD23___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageVD23_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageVD23_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageVD23_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageVD23_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageVD23_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageVD23_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVD23_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVD23_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageVD23_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageVD23_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageVD23_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageVD23
    cast = _swig_new_static_method(_itkImagePython.itkImageVD23_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageVD23_GetPointer)

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

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

          itkImageVD23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageVD23.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageVD23.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageVD23 in _itkImagePython:
_itkImagePython.itkImageVD23_swigregister(itkImageVD23)
class itkImageVD24(itkImageBase4):
    r"""Proxy of C++ itkImageVD24 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(_itkImagePython.itkImageVD24___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageVD24_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageVD24_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageVD24_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageVD24_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageVD24_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageVD24_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVD24_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVD24_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageVD24_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageVD24_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageVD24_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageVD24
    cast = _swig_new_static_method(_itkImagePython.itkImageVD24_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageVD24_GetPointer)

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

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

          itkImageVD24.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageVD24.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageVD24.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageVD24 in _itkImagePython:
_itkImagePython.itkImageVD24_swigregister(itkImageVD24)
class itkImageVD32(itkImageBase2):
    r"""Proxy of C++ itkImageVD32 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(_itkImagePython.itkImageVD32___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageVD32_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageVD32_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageVD32_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageVD32_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageVD32_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageVD32_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVD32_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVD32_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageVD32_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageVD32_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageVD32_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageVD32
    cast = _swig_new_static_method(_itkImagePython.itkImageVD32_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageVD32_GetPointer)

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

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

          itkImageVD32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageVD32.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageVD32.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageVD32 in _itkImagePython:
_itkImagePython.itkImageVD32_swigregister(itkImageVD32)
class itkImageVD33(itkImageBase3):
    r"""Proxy of C++ itkImageVD33 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(_itkImagePython.itkImageVD33___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageVD33_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageVD33_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageVD33_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageVD33_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageVD33_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageVD33_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVD33_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVD33_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageVD33_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageVD33_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageVD33_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageVD33
    cast = _swig_new_static_method(_itkImagePython.itkImageVD33_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageVD33_GetPointer)

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

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

          itkImageVD33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageVD33.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageVD33.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageVD33 in _itkImagePython:
_itkImagePython.itkImageVD33_swigregister(itkImageVD33)
class itkImageVD34(itkImageBase4):
    r"""Proxy of C++ itkImageVD34 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(_itkImagePython.itkImageVD34___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageVD34_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageVD34_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageVD34_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageVD34_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageVD34_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageVD34_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVD34_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVD34_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageVD34_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageVD34_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageVD34_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageVD34
    cast = _swig_new_static_method(_itkImagePython.itkImageVD34_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageVD34_GetPointer)

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

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

          itkImageVD34.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageVD34.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageVD34.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageVD34 in _itkImagePython:
_itkImagePython.itkImageVD34_swigregister(itkImageVD34)
class itkImageVD42(itkImageBase2):
    r"""Proxy of C++ itkImageVD42 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(_itkImagePython.itkImageVD42___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageVD42_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageVD42_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageVD42_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageVD42_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageVD42_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageVD42_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVD42_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVD42_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageVD42_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageVD42_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageVD42_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageVD42
    cast = _swig_new_static_method(_itkImagePython.itkImageVD42_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageVD42_GetPointer)

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

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

          itkImageVD42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageVD42.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageVD42.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageVD42 in _itkImagePython:
_itkImagePython.itkImageVD42_swigregister(itkImageVD42)
class itkImageVD43(itkImageBase3):
    r"""Proxy of C++ itkImageVD43 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(_itkImagePython.itkImageVD43___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageVD43_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageVD43_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageVD43_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageVD43_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageVD43_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageVD43_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVD43_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVD43_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageVD43_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageVD43_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageVD43_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageVD43
    cast = _swig_new_static_method(_itkImagePython.itkImageVD43_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageVD43_GetPointer)

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

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

          itkImageVD43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageVD43.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageVD43.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageVD43 in _itkImagePython:
_itkImagePython.itkImageVD43_swigregister(itkImageVD43)
class itkImageVD44(itkImageBase4):
    r"""Proxy of C++ itkImageVD44 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(_itkImagePython.itkImageVD44___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageVD44_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageVD44_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageVD44_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageVD44_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageVD44_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageVD44_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVD44_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVD44_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageVD44_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageVD44_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageVD44_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageVD44
    cast = _swig_new_static_method(_itkImagePython.itkImageVD44_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageVD44_GetPointer)

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

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

          itkImageVD44.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageVD44.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageVD44.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageVD44 in _itkImagePython:
_itkImagePython.itkImageVD44_swigregister(itkImageVD44)
class itkImageVF12(itkImageBase2):
    r"""Proxy of C++ itkImageVF12 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(_itkImagePython.itkImageVF12___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageVF12_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageVF12_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageVF12_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageVF12_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageVF12_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageVF12_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVF12_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVF12_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageVF12_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageVF12_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageVF12_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageVF12
    cast = _swig_new_static_method(_itkImagePython.itkImageVF12_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageVF12_GetPointer)

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

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

          itkImageVF12.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageVF12.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageVF12.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageVF12 in _itkImagePython:
_itkImagePython.itkImageVF12_swigregister(itkImageVF12)
class itkImageVF13(itkImageBase3):
    r"""Proxy of C++ itkImageVF13 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(_itkImagePython.itkImageVF13___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageVF13_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageVF13_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageVF13_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageVF13_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageVF13_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageVF13_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVF13_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVF13_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageVF13_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageVF13_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageVF13_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageVF13
    cast = _swig_new_static_method(_itkImagePython.itkImageVF13_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageVF13_GetPointer)

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

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

          itkImageVF13.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageVF13.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageVF13.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageVF13 in _itkImagePython:
_itkImagePython.itkImageVF13_swigregister(itkImageVF13)
class itkImageVF22(itkImageBase2):
    r"""Proxy of C++ itkImageVF22 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(_itkImagePython.itkImageVF22___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageVF22_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageVF22_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageVF22_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageVF22_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageVF22_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageVF22_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVF22_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVF22_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageVF22_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageVF22_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageVF22_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageVF22
    cast = _swig_new_static_method(_itkImagePython.itkImageVF22_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageVF22_GetPointer)

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

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

          itkImageVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageVF22.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageVF22.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageVF22 in _itkImagePython:
_itkImagePython.itkImageVF22_swigregister(itkImageVF22)
class itkImageVF23(itkImageBase3):
    r"""Proxy of C++ itkImageVF23 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(_itkImagePython.itkImageVF23___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageVF23_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageVF23_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageVF23_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageVF23_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageVF23_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageVF23_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVF23_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVF23_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageVF23_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageVF23_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageVF23_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageVF23
    cast = _swig_new_static_method(_itkImagePython.itkImageVF23_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageVF23_GetPointer)

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

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

          itkImageVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageVF23.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageVF23.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageVF23 in _itkImagePython:
_itkImagePython.itkImageVF23_swigregister(itkImageVF23)
class itkImageVF32(itkImageBase2):
    r"""Proxy of C++ itkImageVF32 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(_itkImagePython.itkImageVF32___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageVF32_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageVF32_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageVF32_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageVF32_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageVF32_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageVF32_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVF32_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVF32_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageVF32_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageVF32_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageVF32_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageVF32
    cast = _swig_new_static_method(_itkImagePython.itkImageVF32_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageVF32_GetPointer)

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

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

          itkImageVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageVF32.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageVF32.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageVF32 in _itkImagePython:
_itkImagePython.itkImageVF32_swigregister(itkImageVF32)
class itkImageVF33(itkImageBase3):
    r"""Proxy of C++ itkImageVF33 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(_itkImagePython.itkImageVF33___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageVF33_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageVF33_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageVF33_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageVF33_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageVF33_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageVF33_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVF33_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVF33_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageVF33_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageVF33_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageVF33_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageVF33
    cast = _swig_new_static_method(_itkImagePython.itkImageVF33_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageVF33_GetPointer)

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

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

          itkImageVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageVF33.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageVF33.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageVF33 in _itkImagePython:
_itkImagePython.itkImageVF33_swigregister(itkImageVF33)
class itkImageVF42(itkImageBase2):
    r"""Proxy of C++ itkImageVF42 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(_itkImagePython.itkImageVF42___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageVF42_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageVF42_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageVF42_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageVF42_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageVF42_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageVF42_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVF42_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVF42_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageVF42_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageVF42_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageVF42_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageVF42
    cast = _swig_new_static_method(_itkImagePython.itkImageVF42_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageVF42_GetPointer)

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

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

          itkImageVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageVF42.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageVF42.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageVF42 in _itkImagePython:
_itkImagePython.itkImageVF42_swigregister(itkImageVF42)
class itkImageVF43(itkImageBase3):
    r"""Proxy of C++ itkImageVF43 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(_itkImagePython.itkImageVF43___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageVF43_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageVF43_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageVF43_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageVF43_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageVF43_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageVF43_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVF43_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageVF43_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageVF43_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageVF43_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageVF43_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageVF43
    cast = _swig_new_static_method(_itkImagePython.itkImageVF43_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageVF43_GetPointer)

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

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

          itkImageVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageVF43.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageVF43.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageVF43 in _itkImagePython:
_itkImagePython.itkImageVF43_swigregister(itkImageVF43)
class itkImageB2(itkImageBase2):
    r"""Proxy of C++ itkImageB2 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(_itkImagePython.itkImageB2___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageB2_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageB2_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageB2_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageB2_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageB2_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageB2_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageB2_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageB2_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageB2_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageB2_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageB2_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageB2
    cast = _swig_new_static_method(_itkImagePython.itkImageB2_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageB2_GetPointer)

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

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

          itkImageB2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageB2.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageB2.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageB2 in _itkImagePython:
_itkImagePython.itkImageB2_swigregister(itkImageB2)
class itkImageB3(itkImageBase3):
    r"""Proxy of C++ itkImageB3 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(_itkImagePython.itkImageB3___New_orig__)
    Clone = _swig_new_instance_method(_itkImagePython.itkImageB3_Clone)
    Allocate = _swig_new_instance_method(_itkImagePython.itkImageB3_Allocate)
    FillBuffer = _swig_new_instance_method(_itkImagePython.itkImageB3_FillBuffer)
    SetPixel = _swig_new_instance_method(_itkImagePython.itkImageB3_SetPixel)
    GetPixel = _swig_new_instance_method(_itkImagePython.itkImageB3_GetPixel)
    GetBufferPointer = _swig_new_instance_method(_itkImagePython.itkImageB3_GetBufferPointer)
    GetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageB3_GetPixelContainer)
    SetPixelContainer = _swig_new_instance_method(_itkImagePython.itkImageB3_SetPixelContainer)
    Graft = _swig_new_instance_method(_itkImagePython.itkImageB3_Graft)
    GetPixelAccessor = _swig_new_instance_method(_itkImagePython.itkImageB3_GetPixelAccessor)
    GetNeighborhoodAccessor = _swig_new_instance_method(_itkImagePython.itkImageB3_GetNeighborhoodAccessor)
    __swig_destroy__ = _itkImagePython.delete_itkImageB3
    cast = _swig_new_static_method(_itkImagePython.itkImageB3_cast)
    GetPointer = _swig_new_instance_method(_itkImagePython.itkImageB3_GetPointer)

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

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

          itkImageB3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkImageB3.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkImageB3.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageB3 in _itkImagePython:
_itkImagePython.itkImageB3_swigregister(itkImageB3)

