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

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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

def itkImageToImageFilterIRGBAUC3IRGBAUC3_New():
  return itkImageToImageFilterIRGBAUC3IRGBAUC3.New()


def itkImageToImageFilterIRGBAUC2IRGBAUC2_New():
  return itkImageToImageFilterIRGBAUC2IRGBAUC2.New()


def itkImageToImageFilterIRGBUC3IRGBUC3_New():
  return itkImageToImageFilterIRGBUC3IRGBUC3.New()


def itkImageToImageFilterIRGBUC2IRGBUC2_New():
  return itkImageToImageFilterIRGBUC2IRGBUC2.New()


def itkImageToImageFilterIVF23ICVF43_New():
  return itkImageToImageFilterIVF23ICVF43.New()


def itkImageToImageFilterIVF22ICVF42_New():
  return itkImageToImageFilterIVF22ICVF42.New()


def itkImageToImageFilterICVF43ICVF43_New():
  return itkImageToImageFilterICVF43ICVF43.New()


def itkImageToImageFilterICVF42ICVF42_New():
  return itkImageToImageFilterICVF42ICVF42.New()


def itkImageToImageFilterICVF33ICVF33_New():
  return itkImageToImageFilterICVF33ICVF33.New()


def itkImageToImageFilterICVF32ICVF32_New():
  return itkImageToImageFilterICVF32ICVF32.New()


def itkImageToImageFilterICVF23ICVF23_New():
  return itkImageToImageFilterICVF23ICVF23.New()


def itkImageToImageFilterICVF22ICVF22_New():
  return itkImageToImageFilterICVF22ICVF22.New()


def itkImageToImageFilterICVF43IVF43_New():
  return itkImageToImageFilterICVF43IVF43.New()


def itkImageToImageFilterICVF42IVF42_New():
  return itkImageToImageFilterICVF42IVF42.New()


def itkImageToImageFilterICVF33IVF33_New():
  return itkImageToImageFilterICVF33IVF33.New()


def itkImageToImageFilterICVF32IVF32_New():
  return itkImageToImageFilterICVF32IVF32.New()


def itkImageToImageFilterICVF23IVF23_New():
  return itkImageToImageFilterICVF23IVF23.New()


def itkImageToImageFilterICVF22IVF22_New():
  return itkImageToImageFilterICVF22IVF22.New()


def itkImageToImageFilterIVF43ICVF43_New():
  return itkImageToImageFilterIVF43ICVF43.New()


def itkImageToImageFilterIVF42ICVF42_New():
  return itkImageToImageFilterIVF42ICVF42.New()


def itkImageToImageFilterIVF33ICVF33_New():
  return itkImageToImageFilterIVF33ICVF33.New()


def itkImageToImageFilterIVF32ICVF32_New():
  return itkImageToImageFilterIVF32ICVF32.New()


def itkImageToImageFilterIVF23ICVF23_New():
  return itkImageToImageFilterIVF23ICVF23.New()


def itkImageToImageFilterIVF22ICVF22_New():
  return itkImageToImageFilterIVF22ICVF22.New()


def itkImageToImageFilterIVF43IVF43_New():
  return itkImageToImageFilterIVF43IVF43.New()


def itkImageToImageFilterIVF42IVF42_New():
  return itkImageToImageFilterIVF42IVF42.New()


def itkImageToImageFilterIVF33IVF33_New():
  return itkImageToImageFilterIVF33IVF33.New()


def itkImageToImageFilterIVF32IVF32_New():
  return itkImageToImageFilterIVF32IVF32.New()


def itkImageToImageFilterIVF23IVF23_New():
  return itkImageToImageFilterIVF23IVF23.New()


def itkImageToImageFilterIVF22IVF22_New():
  return itkImageToImageFilterIVF22IVF22.New()


def itkImageToImageFilterVIF3VIF3_New():
  return itkImageToImageFilterVIF3VIF3.New()


def itkImageToImageFilterVISS3VISS3_New():
  return itkImageToImageFilterVISS3VISS3.New()


def itkImageToImageFilterVIUC3VIUC3_New():
  return itkImageToImageFilterVIUC3VIUC3.New()


def itkImageToImageFilterVIF2VIF2_New():
  return itkImageToImageFilterVIF2VIF2.New()


def itkImageToImageFilterVISS2VISS2_New():
  return itkImageToImageFilterVISS2VISS2.New()


def itkImageToImageFilterVIUC2VIUC2_New():
  return itkImageToImageFilterVIUC2VIUC2.New()


def itkImageToImageFilterIUL3IUC3_New():
  return itkImageToImageFilterIUL3IUC3.New()


def itkImageToImageFilterIUL2IUC2_New():
  return itkImageToImageFilterIUL2IUC2.New()


def itkImageToImageFilterIUL3ISS3_New():
  return itkImageToImageFilterIUL3ISS3.New()


def itkImageToImageFilterIUL2ISS2_New():
  return itkImageToImageFilterIUL2ISS2.New()


def itkImageToImageFilterIF3IF3_New():
  return itkImageToImageFilterIF3IF3.New()


def itkImageToImageFilterIF2IF2_New():
  return itkImageToImageFilterIF2IF2.New()


def itkImageToImageFilterIF3ISS3_New():
  return itkImageToImageFilterIF3ISS3.New()


def itkImageToImageFilterIF2ISS2_New():
  return itkImageToImageFilterIF2ISS2.New()


def itkImageToImageFilterIF3IUL3_New():
  return itkImageToImageFilterIF3IUL3.New()


def itkImageToImageFilterIF2IUL2_New():
  return itkImageToImageFilterIF2IUL2.New()


def itkImageToImageFilterIF3IUC3_New():
  return itkImageToImageFilterIF3IUC3.New()


def itkImageToImageFilterIF2IUC2_New():
  return itkImageToImageFilterIF2IUC2.New()


def itkImageToImageFilterISS3IF3_New():
  return itkImageToImageFilterISS3IF3.New()


def itkImageToImageFilterISS2IF2_New():
  return itkImageToImageFilterISS2IF2.New()


def itkImageToImageFilterISS3ISS3_New():
  return itkImageToImageFilterISS3ISS3.New()


def itkImageToImageFilterISS2ISS2_New():
  return itkImageToImageFilterISS2ISS2.New()


def itkImageToImageFilterISS3IUL3_New():
  return itkImageToImageFilterISS3IUL3.New()


def itkImageToImageFilterISS2IUL2_New():
  return itkImageToImageFilterISS2IUL2.New()


def itkImageToImageFilterISS3IUC3_New():
  return itkImageToImageFilterISS3IUC3.New()


def itkImageToImageFilterISS2IUC2_New():
  return itkImageToImageFilterISS2IUC2.New()


def itkImageToImageFilterIUC3IF3_New():
  return itkImageToImageFilterIUC3IF3.New()


def itkImageToImageFilterIUC2IF2_New():
  return itkImageToImageFilterIUC2IF2.New()


def itkImageToImageFilterIUC3ISS3_New():
  return itkImageToImageFilterIUC3ISS3.New()


def itkImageToImageFilterIUC2ISS2_New():
  return itkImageToImageFilterIUC2ISS2.New()


def itkImageToImageFilterIUC3IUL3_New():
  return itkImageToImageFilterIUC3IUL3.New()


def itkImageToImageFilterIUC2IUL2_New():
  return itkImageToImageFilterIUC2IUL2.New()


def itkImageToImageFilterIUC3IUC3_New():
  return itkImageToImageFilterIUC3IUC3.New()


def itkImageToImageFilterIUC2IUC2_New():
  return itkImageToImageFilterIUC2IUC2.New()

class itkImageToImageFilterICVF22ICVF22(itkImageSourcePython.itkImageSourceICVF22):
    r"""Proxy of C++ itkImageToImageFilterICVF22ICVF22 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF22ICVF22_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF22ICVF22_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF22ICVF22_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF22ICVF22_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF22ICVF22_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF22ICVF22_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF22ICVF22_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF22ICVF22_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF22ICVF22_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF22ICVF22_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterICVF22ICVF22
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF22ICVF22_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF22ICVF22_GetPointer)

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

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

          itkImageToImageFilterICVF22ICVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF22ICVF22 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterICVF22ICVF22_swigregister(itkImageToImageFilterICVF22ICVF22)
class itkImageToImageFilterICVF22IVF22(itkImageSourcePython.itkImageSourceIVF22):
    r"""Proxy of C++ itkImageToImageFilterICVF22IVF22 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF22IVF22_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF22IVF22_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF22IVF22_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF22IVF22_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF22IVF22_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF22IVF22_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF22IVF22_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF22IVF22_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF22IVF22_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF22IVF22_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterICVF22IVF22
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF22IVF22_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF22IVF22_GetPointer)

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

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

          itkImageToImageFilterICVF22IVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF22IVF22 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterICVF22IVF22_swigregister(itkImageToImageFilterICVF22IVF22)
class itkImageToImageFilterICVF23ICVF23(itkImageSourcePython.itkImageSourceICVF23):
    r"""Proxy of C++ itkImageToImageFilterICVF23ICVF23 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF23ICVF23_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF23ICVF23_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF23ICVF23_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF23ICVF23_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF23ICVF23_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF23ICVF23_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF23ICVF23_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF23ICVF23_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF23ICVF23_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF23ICVF23_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterICVF23ICVF23
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF23ICVF23_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF23ICVF23_GetPointer)

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

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

          itkImageToImageFilterICVF23ICVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF23ICVF23 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterICVF23ICVF23_swigregister(itkImageToImageFilterICVF23ICVF23)
class itkImageToImageFilterICVF23IVF23(itkImageSourcePython.itkImageSourceIVF23):
    r"""Proxy of C++ itkImageToImageFilterICVF23IVF23 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF23IVF23_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF23IVF23_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF23IVF23_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF23IVF23_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF23IVF23_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF23IVF23_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF23IVF23_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF23IVF23_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF23IVF23_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF23IVF23_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterICVF23IVF23
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF23IVF23_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF23IVF23_GetPointer)

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

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

          itkImageToImageFilterICVF23IVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF23IVF23 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterICVF23IVF23_swigregister(itkImageToImageFilterICVF23IVF23)
class itkImageToImageFilterICVF32ICVF32(itkImageSourcePython.itkImageSourceICVF32):
    r"""Proxy of C++ itkImageToImageFilterICVF32ICVF32 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF32ICVF32_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF32ICVF32_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF32ICVF32_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF32ICVF32_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF32ICVF32_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF32ICVF32_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF32ICVF32_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF32ICVF32_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF32ICVF32_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF32ICVF32_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterICVF32ICVF32
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF32ICVF32_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF32ICVF32_GetPointer)

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

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

          itkImageToImageFilterICVF32ICVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF32ICVF32 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterICVF32ICVF32_swigregister(itkImageToImageFilterICVF32ICVF32)
class itkImageToImageFilterICVF32IVF32(itkImageSourcePython.itkImageSourceIVF32):
    r"""Proxy of C++ itkImageToImageFilterICVF32IVF32 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF32IVF32_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF32IVF32_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF32IVF32_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF32IVF32_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF32IVF32_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF32IVF32_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF32IVF32_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF32IVF32_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF32IVF32_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF32IVF32_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterICVF32IVF32
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF32IVF32_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF32IVF32_GetPointer)

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

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

          itkImageToImageFilterICVF32IVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF32IVF32 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterICVF32IVF32_swigregister(itkImageToImageFilterICVF32IVF32)
class itkImageToImageFilterICVF33ICVF33(itkImageSourcePython.itkImageSourceICVF33):
    r"""Proxy of C++ itkImageToImageFilterICVF33ICVF33 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF33ICVF33_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF33ICVF33_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF33ICVF33_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF33ICVF33_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF33ICVF33_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF33ICVF33_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF33ICVF33_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF33ICVF33_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF33ICVF33_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF33ICVF33_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterICVF33ICVF33
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF33ICVF33_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF33ICVF33_GetPointer)

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

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

          itkImageToImageFilterICVF33ICVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF33ICVF33 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterICVF33ICVF33_swigregister(itkImageToImageFilterICVF33ICVF33)
class itkImageToImageFilterICVF33IVF33(itkImageSourcePython.itkImageSourceIVF33):
    r"""Proxy of C++ itkImageToImageFilterICVF33IVF33 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF33IVF33_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF33IVF33_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF33IVF33_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF33IVF33_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF33IVF33_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF33IVF33_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF33IVF33_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF33IVF33_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF33IVF33_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF33IVF33_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterICVF33IVF33
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF33IVF33_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF33IVF33_GetPointer)

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

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

          itkImageToImageFilterICVF33IVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF33IVF33 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterICVF33IVF33_swigregister(itkImageToImageFilterICVF33IVF33)
class itkImageToImageFilterICVF42ICVF42(itkImageSourcePython.itkImageSourceICVF42):
    r"""Proxy of C++ itkImageToImageFilterICVF42ICVF42 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF42ICVF42_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF42ICVF42_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF42ICVF42_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF42ICVF42_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF42ICVF42_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF42ICVF42_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF42ICVF42_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF42ICVF42_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF42ICVF42_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF42ICVF42_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterICVF42ICVF42
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF42ICVF42_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF42ICVF42_GetPointer)

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

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

          itkImageToImageFilterICVF42ICVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF42ICVF42 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterICVF42ICVF42_swigregister(itkImageToImageFilterICVF42ICVF42)
class itkImageToImageFilterICVF42IVF42(itkImageSourcePython.itkImageSourceIVF42):
    r"""Proxy of C++ itkImageToImageFilterICVF42IVF42 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF42IVF42_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF42IVF42_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF42IVF42_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF42IVF42_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF42IVF42_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF42IVF42_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF42IVF42_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF42IVF42_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF42IVF42_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF42IVF42_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterICVF42IVF42
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF42IVF42_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF42IVF42_GetPointer)

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

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

          itkImageToImageFilterICVF42IVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF42IVF42 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterICVF42IVF42_swigregister(itkImageToImageFilterICVF42IVF42)
class itkImageToImageFilterICVF43ICVF43(itkImageSourcePython.itkImageSourceICVF43):
    r"""Proxy of C++ itkImageToImageFilterICVF43ICVF43 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF43ICVF43_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF43ICVF43_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF43ICVF43_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF43ICVF43_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF43ICVF43_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF43ICVF43_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF43ICVF43_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF43ICVF43_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF43ICVF43_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF43ICVF43_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterICVF43ICVF43
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF43ICVF43_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF43ICVF43_GetPointer)

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

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

          itkImageToImageFilterICVF43ICVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF43ICVF43 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterICVF43ICVF43_swigregister(itkImageToImageFilterICVF43ICVF43)
class itkImageToImageFilterICVF43IVF43(itkImageSourcePython.itkImageSourceIVF43):
    r"""Proxy of C++ itkImageToImageFilterICVF43IVF43 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF43IVF43_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF43IVF43_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF43IVF43_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF43IVF43_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF43IVF43_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF43IVF43_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF43IVF43_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF43IVF43_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF43IVF43_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF43IVF43_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterICVF43IVF43
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF43IVF43_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterICVF43IVF43_GetPointer)

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

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

          itkImageToImageFilterICVF43IVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF43IVF43 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterICVF43IVF43_swigregister(itkImageToImageFilterICVF43IVF43)
class itkImageToImageFilterIF2IF2(itkImageSourcePython.itkImageSourceIF2):
    r"""Proxy of C++ itkImageToImageFilterIF2IF2 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IF2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IF2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IF2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IF2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IF2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IF2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IF2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IF2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IF2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IF2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIF2IF2
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IF2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IF2_GetPointer)

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

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

          itkImageToImageFilterIF2IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF2IF2 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIF2IF2_swigregister(itkImageToImageFilterIF2IF2)
class itkImageToImageFilterIF2ISS2(itkImageSourcePython.itkImageSourceISS2):
    r"""Proxy of C++ itkImageToImageFilterIF2ISS2 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2ISS2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2ISS2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2ISS2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2ISS2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2ISS2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2ISS2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2ISS2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2ISS2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2ISS2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2ISS2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIF2ISS2
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2ISS2_GetPointer)

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

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

          itkImageToImageFilterIF2ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF2ISS2 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIF2ISS2_swigregister(itkImageToImageFilterIF2ISS2)
class itkImageToImageFilterIF2IUC2(itkImageSourcePython.itkImageSourceIUC2):
    r"""Proxy of C++ itkImageToImageFilterIF2IUC2 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIF2IUC2
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IUC2_GetPointer)

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

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

          itkImageToImageFilterIF2IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF2IUC2 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIF2IUC2_swigregister(itkImageToImageFilterIF2IUC2)
class itkImageToImageFilterIF2IUL2(itkImageSourcePython.itkImageSourceIUL2):
    r"""Proxy of C++ itkImageToImageFilterIF2IUL2 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IUL2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IUL2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IUL2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IUL2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IUL2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IUL2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IUL2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IUL2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IUL2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IUL2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIF2IUL2
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IUL2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF2IUL2_GetPointer)

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

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

          itkImageToImageFilterIF2IUL2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF2IUL2 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIF2IUL2_swigregister(itkImageToImageFilterIF2IUL2)
class itkImageToImageFilterIF3IF3(itkImageSourcePython.itkImageSourceIF3):
    r"""Proxy of C++ itkImageToImageFilterIF3IF3 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IF3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IF3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IF3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IF3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IF3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IF3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IF3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IF3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IF3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IF3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIF3IF3
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IF3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IF3_GetPointer)

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

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

          itkImageToImageFilterIF3IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF3IF3 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIF3IF3_swigregister(itkImageToImageFilterIF3IF3)
class itkImageToImageFilterIF3ISS3(itkImageSourcePython.itkImageSourceISS3):
    r"""Proxy of C++ itkImageToImageFilterIF3ISS3 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3ISS3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3ISS3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3ISS3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3ISS3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3ISS3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3ISS3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3ISS3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3ISS3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3ISS3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3ISS3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIF3ISS3
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3ISS3_GetPointer)

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

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

          itkImageToImageFilterIF3ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF3ISS3 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIF3ISS3_swigregister(itkImageToImageFilterIF3ISS3)
class itkImageToImageFilterIF3IUC3(itkImageSourcePython.itkImageSourceIUC3):
    r"""Proxy of C++ itkImageToImageFilterIF3IUC3 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIF3IUC3
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IUC3_GetPointer)

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

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

          itkImageToImageFilterIF3IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF3IUC3 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIF3IUC3_swigregister(itkImageToImageFilterIF3IUC3)
class itkImageToImageFilterIF3IUL3(itkImageSourcePython.itkImageSourceIUL3):
    r"""Proxy of C++ itkImageToImageFilterIF3IUL3 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IUL3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IUL3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IUL3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IUL3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IUL3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IUL3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IUL3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IUL3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IUL3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IUL3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIF3IUL3
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IUL3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIF3IUL3_GetPointer)

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

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

          itkImageToImageFilterIF3IUL3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF3IUL3 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIF3IUL3_swigregister(itkImageToImageFilterIF3IUL3)
class itkImageToImageFilterIRGBAUC2IRGBAUC2(itkImageSourcePython.itkImageSourceIRGBAUC2):
    r"""Proxy of C++ itkImageToImageFilterIRGBAUC2IRGBAUC2 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC2IRGBAUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC2IRGBAUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC2IRGBAUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC2IRGBAUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC2IRGBAUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC2IRGBAUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC2IRGBAUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC2IRGBAUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC2IRGBAUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC2IRGBAUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIRGBAUC2IRGBAUC2
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC2IRGBAUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC2IRGBAUC2_GetPointer)

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

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

          itkImageToImageFilterIRGBAUC2IRGBAUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIRGBAUC2IRGBAUC2 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC2IRGBAUC2_swigregister(itkImageToImageFilterIRGBAUC2IRGBAUC2)
class itkImageToImageFilterIRGBAUC3IRGBAUC3(itkImageSourcePython.itkImageSourceIRGBAUC3):
    r"""Proxy of C++ itkImageToImageFilterIRGBAUC3IRGBAUC3 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC3IRGBAUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC3IRGBAUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC3IRGBAUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC3IRGBAUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC3IRGBAUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC3IRGBAUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC3IRGBAUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC3IRGBAUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC3IRGBAUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC3IRGBAUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIRGBAUC3IRGBAUC3
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC3IRGBAUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC3IRGBAUC3_GetPointer)

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

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

          itkImageToImageFilterIRGBAUC3IRGBAUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIRGBAUC3IRGBAUC3 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC3IRGBAUC3_swigregister(itkImageToImageFilterIRGBAUC3IRGBAUC3)
class itkImageToImageFilterIRGBUC2IRGBUC2(itkImageSourcePython.itkImageSourceIRGBUC2):
    r"""Proxy of C++ itkImageToImageFilterIRGBUC2IRGBUC2 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC2IRGBUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC2IRGBUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC2IRGBUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC2IRGBUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC2IRGBUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC2IRGBUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC2IRGBUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC2IRGBUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC2IRGBUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC2IRGBUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIRGBUC2IRGBUC2
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC2IRGBUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC2IRGBUC2_GetPointer)

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

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

          itkImageToImageFilterIRGBUC2IRGBUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIRGBUC2IRGBUC2 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC2IRGBUC2_swigregister(itkImageToImageFilterIRGBUC2IRGBUC2)
class itkImageToImageFilterIRGBUC3IRGBUC3(itkImageSourcePython.itkImageSourceIRGBUC3):
    r"""Proxy of C++ itkImageToImageFilterIRGBUC3IRGBUC3 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC3IRGBUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC3IRGBUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC3IRGBUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC3IRGBUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC3IRGBUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC3IRGBUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC3IRGBUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC3IRGBUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC3IRGBUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC3IRGBUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIRGBUC3IRGBUC3
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC3IRGBUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC3IRGBUC3_GetPointer)

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

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

          itkImageToImageFilterIRGBUC3IRGBUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIRGBUC3IRGBUC3 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC3IRGBUC3_swigregister(itkImageToImageFilterIRGBUC3IRGBUC3)
class itkImageToImageFilterISS2IF2(itkImageSourcePython.itkImageSourceIF2):
    r"""Proxy of C++ itkImageToImageFilterISS2IF2 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IF2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IF2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IF2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IF2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IF2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IF2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IF2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IF2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IF2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IF2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterISS2IF2
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IF2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IF2_GetPointer)

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

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

          itkImageToImageFilterISS2IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS2IF2 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterISS2IF2_swigregister(itkImageToImageFilterISS2IF2)
class itkImageToImageFilterISS2ISS2(itkImageSourcePython.itkImageSourceISS2):
    r"""Proxy of C++ itkImageToImageFilterISS2ISS2 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2ISS2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2ISS2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2ISS2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2ISS2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2ISS2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2ISS2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2ISS2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2ISS2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2ISS2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2ISS2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterISS2ISS2
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2ISS2_GetPointer)

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

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

          itkImageToImageFilterISS2ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS2ISS2 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterISS2ISS2_swigregister(itkImageToImageFilterISS2ISS2)
class itkImageToImageFilterISS2IUC2(itkImageSourcePython.itkImageSourceIUC2):
    r"""Proxy of C++ itkImageToImageFilterISS2IUC2 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterISS2IUC2
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IUC2_GetPointer)

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

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

          itkImageToImageFilterISS2IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS2IUC2 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterISS2IUC2_swigregister(itkImageToImageFilterISS2IUC2)
class itkImageToImageFilterISS2IUL2(itkImageSourcePython.itkImageSourceIUL2):
    r"""Proxy of C++ itkImageToImageFilterISS2IUL2 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IUL2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IUL2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IUL2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IUL2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IUL2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IUL2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IUL2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IUL2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IUL2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IUL2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterISS2IUL2
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IUL2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS2IUL2_GetPointer)

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

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

          itkImageToImageFilterISS2IUL2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS2IUL2 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterISS2IUL2_swigregister(itkImageToImageFilterISS2IUL2)
class itkImageToImageFilterISS3IF3(itkImageSourcePython.itkImageSourceIF3):
    r"""Proxy of C++ itkImageToImageFilterISS3IF3 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IF3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IF3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IF3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IF3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IF3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IF3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IF3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IF3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IF3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IF3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterISS3IF3
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IF3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IF3_GetPointer)

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

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

          itkImageToImageFilterISS3IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS3IF3 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterISS3IF3_swigregister(itkImageToImageFilterISS3IF3)
class itkImageToImageFilterISS3ISS3(itkImageSourcePython.itkImageSourceISS3):
    r"""Proxy of C++ itkImageToImageFilterISS3ISS3 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3ISS3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3ISS3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3ISS3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3ISS3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3ISS3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3ISS3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3ISS3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3ISS3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3ISS3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3ISS3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterISS3ISS3
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3ISS3_GetPointer)

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

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

          itkImageToImageFilterISS3ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS3ISS3 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterISS3ISS3_swigregister(itkImageToImageFilterISS3ISS3)
class itkImageToImageFilterISS3IUC3(itkImageSourcePython.itkImageSourceIUC3):
    r"""Proxy of C++ itkImageToImageFilterISS3IUC3 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterISS3IUC3
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IUC3_GetPointer)

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

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

          itkImageToImageFilterISS3IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS3IUC3 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterISS3IUC3_swigregister(itkImageToImageFilterISS3IUC3)
class itkImageToImageFilterISS3IUL3(itkImageSourcePython.itkImageSourceIUL3):
    r"""Proxy of C++ itkImageToImageFilterISS3IUL3 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IUL3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IUL3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IUL3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IUL3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IUL3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IUL3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IUL3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IUL3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IUL3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IUL3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterISS3IUL3
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IUL3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterISS3IUL3_GetPointer)

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

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

          itkImageToImageFilterISS3IUL3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS3IUL3 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterISS3IUL3_swigregister(itkImageToImageFilterISS3IUL3)
class itkImageToImageFilterIUC2IF2(itkImageSourcePython.itkImageSourceIF2):
    r"""Proxy of C++ itkImageToImageFilterIUC2IF2 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IF2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IF2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IF2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IF2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IF2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IF2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IF2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IF2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IF2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IF2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIUC2IF2
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IF2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IF2_GetPointer)

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

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

          itkImageToImageFilterIUC2IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC2IF2 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IF2_swigregister(itkImageToImageFilterIUC2IF2)
class itkImageToImageFilterIUC2ISS2(itkImageSourcePython.itkImageSourceISS2):
    r"""Proxy of C++ itkImageToImageFilterIUC2ISS2 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2ISS2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2ISS2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2ISS2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2ISS2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2ISS2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2ISS2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2ISS2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2ISS2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2ISS2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2ISS2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIUC2ISS2
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2ISS2_GetPointer)

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

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

          itkImageToImageFilterIUC2ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC2ISS2 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIUC2ISS2_swigregister(itkImageToImageFilterIUC2ISS2)
class itkImageToImageFilterIUC2IUC2(itkImageSourcePython.itkImageSourceIUC2):
    r"""Proxy of C++ itkImageToImageFilterIUC2IUC2 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIUC2IUC2
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUC2_GetPointer)

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

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

          itkImageToImageFilterIUC2IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC2IUC2 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUC2_swigregister(itkImageToImageFilterIUC2IUC2)
class itkImageToImageFilterIUC2IUL2(itkImageSourcePython.itkImageSourceIUL2):
    r"""Proxy of C++ itkImageToImageFilterIUC2IUL2 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUL2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUL2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUL2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUL2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUL2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUL2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUL2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUL2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUL2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUL2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIUC2IUL2
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUL2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUL2_GetPointer)

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

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

          itkImageToImageFilterIUC2IUL2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC2IUL2 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUL2_swigregister(itkImageToImageFilterIUC2IUL2)
class itkImageToImageFilterIUC3IF3(itkImageSourcePython.itkImageSourceIF3):
    r"""Proxy of C++ itkImageToImageFilterIUC3IF3 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IF3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IF3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IF3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IF3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IF3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IF3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IF3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IF3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IF3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IF3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIUC3IF3
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IF3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IF3_GetPointer)

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

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

          itkImageToImageFilterIUC3IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC3IF3 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IF3_swigregister(itkImageToImageFilterIUC3IF3)
class itkImageToImageFilterIUC3ISS3(itkImageSourcePython.itkImageSourceISS3):
    r"""Proxy of C++ itkImageToImageFilterIUC3ISS3 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3ISS3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3ISS3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3ISS3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3ISS3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3ISS3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3ISS3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3ISS3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3ISS3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3ISS3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3ISS3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIUC3ISS3
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3ISS3_GetPointer)

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

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

          itkImageToImageFilterIUC3ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC3ISS3 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIUC3ISS3_swigregister(itkImageToImageFilterIUC3ISS3)
class itkImageToImageFilterIUC3IUC3(itkImageSourcePython.itkImageSourceIUC3):
    r"""Proxy of C++ itkImageToImageFilterIUC3IUC3 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIUC3IUC3
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUC3_GetPointer)

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

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

          itkImageToImageFilterIUC3IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC3IUC3 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUC3_swigregister(itkImageToImageFilterIUC3IUC3)
class itkImageToImageFilterIUC3IUL3(itkImageSourcePython.itkImageSourceIUL3):
    r"""Proxy of C++ itkImageToImageFilterIUC3IUL3 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUL3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUL3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUL3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUL3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUL3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUL3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUL3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUL3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUL3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUL3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIUC3IUL3
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUL3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUL3_GetPointer)

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

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

          itkImageToImageFilterIUC3IUL3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC3IUL3 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUL3_swigregister(itkImageToImageFilterIUC3IUL3)
class itkImageToImageFilterIUL2ISS2(itkImageSourcePython.itkImageSourceISS2):
    r"""Proxy of C++ itkImageToImageFilterIUL2ISS2 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL2ISS2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL2ISS2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL2ISS2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL2ISS2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL2ISS2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL2ISS2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL2ISS2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL2ISS2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL2ISS2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL2ISS2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIUL2ISS2
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL2ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL2ISS2_GetPointer)

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

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

          itkImageToImageFilterIUL2ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUL2ISS2 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIUL2ISS2_swigregister(itkImageToImageFilterIUL2ISS2)
class itkImageToImageFilterIUL2IUC2(itkImageSourcePython.itkImageSourceIUC2):
    r"""Proxy of C++ itkImageToImageFilterIUL2IUC2 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL2IUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL2IUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL2IUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL2IUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL2IUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL2IUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL2IUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL2IUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL2IUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL2IUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIUL2IUC2
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL2IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL2IUC2_GetPointer)

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

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

          itkImageToImageFilterIUL2IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUL2IUC2 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIUL2IUC2_swigregister(itkImageToImageFilterIUL2IUC2)
class itkImageToImageFilterIUL3ISS3(itkImageSourcePython.itkImageSourceISS3):
    r"""Proxy of C++ itkImageToImageFilterIUL3ISS3 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL3ISS3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL3ISS3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL3ISS3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL3ISS3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL3ISS3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL3ISS3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL3ISS3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL3ISS3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL3ISS3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL3ISS3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIUL3ISS3
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL3ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL3ISS3_GetPointer)

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

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

          itkImageToImageFilterIUL3ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUL3ISS3 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIUL3ISS3_swigregister(itkImageToImageFilterIUL3ISS3)
class itkImageToImageFilterIUL3IUC3(itkImageSourcePython.itkImageSourceIUC3):
    r"""Proxy of C++ itkImageToImageFilterIUL3IUC3 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL3IUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL3IUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL3IUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL3IUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL3IUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL3IUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL3IUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL3IUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL3IUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL3IUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIUL3IUC3
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL3IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIUL3IUC3_GetPointer)

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

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

          itkImageToImageFilterIUL3IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUL3IUC3 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIUL3IUC3_swigregister(itkImageToImageFilterIUL3IUC3)
class itkImageToImageFilterIVF22ICVF22(itkImageSourcePython.itkImageSourceICVF22):
    r"""Proxy of C++ itkImageToImageFilterIVF22ICVF22 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22ICVF22_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22ICVF22_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22ICVF22_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22ICVF22_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22ICVF22_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22ICVF22_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22ICVF22_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22ICVF22_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22ICVF22_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22ICVF22_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIVF22ICVF22
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22ICVF22_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22ICVF22_GetPointer)

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

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

          itkImageToImageFilterIVF22ICVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF22ICVF22 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIVF22ICVF22_swigregister(itkImageToImageFilterIVF22ICVF22)
class itkImageToImageFilterIVF22ICVF42(itkImageSourcePython.itkImageSourceICVF42):
    r"""Proxy of C++ itkImageToImageFilterIVF22ICVF42 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22ICVF42_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22ICVF42_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22ICVF42_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22ICVF42_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22ICVF42_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22ICVF42_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22ICVF42_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22ICVF42_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22ICVF42_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22ICVF42_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIVF22ICVF42
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22ICVF42_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22ICVF42_GetPointer)

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

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

          itkImageToImageFilterIVF22ICVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF22ICVF42 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIVF22ICVF42_swigregister(itkImageToImageFilterIVF22ICVF42)
class itkImageToImageFilterIVF22IVF22(itkImageSourcePython.itkImageSourceIVF22):
    r"""Proxy of C++ itkImageToImageFilterIVF22IVF22 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22IVF22_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22IVF22_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22IVF22_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22IVF22_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22IVF22_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22IVF22_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22IVF22_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22IVF22_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22IVF22_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22IVF22_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIVF22IVF22
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22IVF22_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF22IVF22_GetPointer)

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

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

          itkImageToImageFilterIVF22IVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF22IVF22 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIVF22IVF22_swigregister(itkImageToImageFilterIVF22IVF22)
class itkImageToImageFilterIVF23ICVF23(itkImageSourcePython.itkImageSourceICVF23):
    r"""Proxy of C++ itkImageToImageFilterIVF23ICVF23 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23ICVF23_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23ICVF23_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23ICVF23_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23ICVF23_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23ICVF23_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23ICVF23_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23ICVF23_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23ICVF23_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23ICVF23_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23ICVF23_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIVF23ICVF23
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23ICVF23_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23ICVF23_GetPointer)

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

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

          itkImageToImageFilterIVF23ICVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF23ICVF23 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIVF23ICVF23_swigregister(itkImageToImageFilterIVF23ICVF23)
class itkImageToImageFilterIVF23ICVF43(itkImageSourcePython.itkImageSourceICVF43):
    r"""Proxy of C++ itkImageToImageFilterIVF23ICVF43 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23ICVF43_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23ICVF43_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23ICVF43_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23ICVF43_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23ICVF43_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23ICVF43_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23ICVF43_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23ICVF43_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23ICVF43_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23ICVF43_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIVF23ICVF43
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23ICVF43_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23ICVF43_GetPointer)

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

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

          itkImageToImageFilterIVF23ICVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF23ICVF43 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIVF23ICVF43_swigregister(itkImageToImageFilterIVF23ICVF43)
class itkImageToImageFilterIVF23IVF23(itkImageSourcePython.itkImageSourceIVF23):
    r"""Proxy of C++ itkImageToImageFilterIVF23IVF23 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23IVF23_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23IVF23_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23IVF23_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23IVF23_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23IVF23_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23IVF23_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23IVF23_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23IVF23_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23IVF23_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23IVF23_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIVF23IVF23
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23IVF23_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF23IVF23_GetPointer)

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

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

          itkImageToImageFilterIVF23IVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF23IVF23 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIVF23IVF23_swigregister(itkImageToImageFilterIVF23IVF23)
class itkImageToImageFilterIVF32ICVF32(itkImageSourcePython.itkImageSourceICVF32):
    r"""Proxy of C++ itkImageToImageFilterIVF32ICVF32 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF32ICVF32_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF32ICVF32_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF32ICVF32_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF32ICVF32_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF32ICVF32_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF32ICVF32_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF32ICVF32_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF32ICVF32_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF32ICVF32_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF32ICVF32_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIVF32ICVF32
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF32ICVF32_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF32ICVF32_GetPointer)

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

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

          itkImageToImageFilterIVF32ICVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF32ICVF32 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIVF32ICVF32_swigregister(itkImageToImageFilterIVF32ICVF32)
class itkImageToImageFilterIVF32IVF32(itkImageSourcePython.itkImageSourceIVF32):
    r"""Proxy of C++ itkImageToImageFilterIVF32IVF32 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF32IVF32_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF32IVF32_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF32IVF32_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF32IVF32_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF32IVF32_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF32IVF32_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF32IVF32_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF32IVF32_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF32IVF32_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF32IVF32_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIVF32IVF32
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF32IVF32_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF32IVF32_GetPointer)

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

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

          itkImageToImageFilterIVF32IVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF32IVF32 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIVF32IVF32_swigregister(itkImageToImageFilterIVF32IVF32)
class itkImageToImageFilterIVF33ICVF33(itkImageSourcePython.itkImageSourceICVF33):
    r"""Proxy of C++ itkImageToImageFilterIVF33ICVF33 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF33ICVF33_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF33ICVF33_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF33ICVF33_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF33ICVF33_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF33ICVF33_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF33ICVF33_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF33ICVF33_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF33ICVF33_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF33ICVF33_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF33ICVF33_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIVF33ICVF33
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF33ICVF33_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF33ICVF33_GetPointer)

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

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

          itkImageToImageFilterIVF33ICVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF33ICVF33 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIVF33ICVF33_swigregister(itkImageToImageFilterIVF33ICVF33)
class itkImageToImageFilterIVF33IVF33(itkImageSourcePython.itkImageSourceIVF33):
    r"""Proxy of C++ itkImageToImageFilterIVF33IVF33 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF33IVF33_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF33IVF33_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF33IVF33_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF33IVF33_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF33IVF33_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF33IVF33_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF33IVF33_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF33IVF33_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF33IVF33_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF33IVF33_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIVF33IVF33
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF33IVF33_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF33IVF33_GetPointer)

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

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

          itkImageToImageFilterIVF33IVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF33IVF33 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIVF33IVF33_swigregister(itkImageToImageFilterIVF33IVF33)
class itkImageToImageFilterIVF42ICVF42(itkImageSourcePython.itkImageSourceICVF42):
    r"""Proxy of C++ itkImageToImageFilterIVF42ICVF42 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF42ICVF42_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF42ICVF42_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF42ICVF42_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF42ICVF42_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF42ICVF42_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF42ICVF42_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF42ICVF42_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF42ICVF42_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF42ICVF42_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF42ICVF42_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIVF42ICVF42
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF42ICVF42_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF42ICVF42_GetPointer)

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

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

          itkImageToImageFilterIVF42ICVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF42ICVF42 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIVF42ICVF42_swigregister(itkImageToImageFilterIVF42ICVF42)
class itkImageToImageFilterIVF42IVF42(itkImageSourcePython.itkImageSourceIVF42):
    r"""Proxy of C++ itkImageToImageFilterIVF42IVF42 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF42IVF42_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF42IVF42_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF42IVF42_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF42IVF42_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF42IVF42_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF42IVF42_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF42IVF42_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF42IVF42_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF42IVF42_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF42IVF42_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIVF42IVF42
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF42IVF42_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF42IVF42_GetPointer)

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

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

          itkImageToImageFilterIVF42IVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF42IVF42 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIVF42IVF42_swigregister(itkImageToImageFilterIVF42IVF42)
class itkImageToImageFilterIVF43ICVF43(itkImageSourcePython.itkImageSourceICVF43):
    r"""Proxy of C++ itkImageToImageFilterIVF43ICVF43 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF43ICVF43_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF43ICVF43_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF43ICVF43_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF43ICVF43_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF43ICVF43_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF43ICVF43_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF43ICVF43_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF43ICVF43_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF43ICVF43_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF43ICVF43_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIVF43ICVF43
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF43ICVF43_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF43ICVF43_GetPointer)

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

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

          itkImageToImageFilterIVF43ICVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF43ICVF43 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIVF43ICVF43_swigregister(itkImageToImageFilterIVF43ICVF43)
class itkImageToImageFilterIVF43IVF43(itkImageSourcePython.itkImageSourceIVF43):
    r"""Proxy of C++ itkImageToImageFilterIVF43IVF43 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF43IVF43_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF43IVF43_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF43IVF43_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF43IVF43_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF43IVF43_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF43IVF43_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF43IVF43_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF43IVF43_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF43IVF43_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF43IVF43_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterIVF43IVF43
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF43IVF43_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterIVF43IVF43_GetPointer)

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

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

          itkImageToImageFilterIVF43IVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF43IVF43 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterIVF43IVF43_swigregister(itkImageToImageFilterIVF43IVF43)
class itkImageToImageFilterVIF2VIF2(itkImageSourcePython.itkImageSourceVIF2):
    r"""Proxy of C++ itkImageToImageFilterVIF2VIF2 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIF2VIF2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIF2VIF2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIF2VIF2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIF2VIF2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIF2VIF2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIF2VIF2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIF2VIF2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIF2VIF2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIF2VIF2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIF2VIF2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterVIF2VIF2
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIF2VIF2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIF2VIF2_GetPointer)

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

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

          itkImageToImageFilterVIF2VIF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterVIF2VIF2 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterVIF2VIF2_swigregister(itkImageToImageFilterVIF2VIF2)
class itkImageToImageFilterVIF3VIF3(itkImageSourcePython.itkImageSourceVIF3):
    r"""Proxy of C++ itkImageToImageFilterVIF3VIF3 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIF3VIF3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIF3VIF3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIF3VIF3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIF3VIF3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIF3VIF3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIF3VIF3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIF3VIF3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIF3VIF3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIF3VIF3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIF3VIF3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterVIF3VIF3
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIF3VIF3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIF3VIF3_GetPointer)

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

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

          itkImageToImageFilterVIF3VIF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterVIF3VIF3 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterVIF3VIF3_swigregister(itkImageToImageFilterVIF3VIF3)
class itkImageToImageFilterVISS2VISS2(itkImageSourcePython.itkImageSourceVISS2):
    r"""Proxy of C++ itkImageToImageFilterVISS2VISS2 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVISS2VISS2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVISS2VISS2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVISS2VISS2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVISS2VISS2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVISS2VISS2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVISS2VISS2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVISS2VISS2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVISS2VISS2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVISS2VISS2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVISS2VISS2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterVISS2VISS2
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterVISS2VISS2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVISS2VISS2_GetPointer)

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

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

          itkImageToImageFilterVISS2VISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterVISS2VISS2 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterVISS2VISS2_swigregister(itkImageToImageFilterVISS2VISS2)
class itkImageToImageFilterVISS3VISS3(itkImageSourcePython.itkImageSourceVISS3):
    r"""Proxy of C++ itkImageToImageFilterVISS3VISS3 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVISS3VISS3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVISS3VISS3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVISS3VISS3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVISS3VISS3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVISS3VISS3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVISS3VISS3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVISS3VISS3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVISS3VISS3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVISS3VISS3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVISS3VISS3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterVISS3VISS3
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterVISS3VISS3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVISS3VISS3_GetPointer)

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

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

          itkImageToImageFilterVISS3VISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterVISS3VISS3 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterVISS3VISS3_swigregister(itkImageToImageFilterVISS3VISS3)
class itkImageToImageFilterVIUC2VIUC2(itkImageSourcePython.itkImageSourceVIUC2):
    r"""Proxy of C++ itkImageToImageFilterVIUC2VIUC2 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIUC2VIUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIUC2VIUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIUC2VIUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIUC2VIUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIUC2VIUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIUC2VIUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIUC2VIUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIUC2VIUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIUC2VIUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIUC2VIUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterVIUC2VIUC2
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIUC2VIUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIUC2VIUC2_GetPointer)

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

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

          itkImageToImageFilterVIUC2VIUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterVIUC2VIUC2 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterVIUC2VIUC2_swigregister(itkImageToImageFilterVIUC2VIUC2)
class itkImageToImageFilterVIUC3VIUC3(itkImageSourcePython.itkImageSourceVIUC3):
    r"""Proxy of C++ itkImageToImageFilterVIUC3VIUC3 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
    SetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIUC3VIUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIUC3VIUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIUC3VIUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIUC3VIUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIUC3VIUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIUC3VIUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIUC3VIUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIUC3VIUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIUC3VIUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIUC3VIUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterAPython.delete_itkImageToImageFilterVIUC3VIUC3
    cast = _swig_new_static_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIUC3VIUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterAPython.itkImageToImageFilterVIUC3VIUC3_GetPointer)

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

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

          itkImageToImageFilterVIUC3VIUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterVIUC3VIUC3 in _itkImageToImageFilterAPython:
_itkImageToImageFilterAPython.itkImageToImageFilterVIUC3VIUC3_swigregister(itkImageToImageFilterVIUC3VIUC3)

