# 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 itkImageRegionPython
import itkSizePython
import pyBasePython
import ITKCommonBasePython
import itkIndexPython
import itkOffsetPython
import itkVectorImagePython
import itkVariableLengthVectorPython
import stdcomplexPython
import itkImagePython
import itkRGBAPixelPython
import itkFixedArrayPython
import itkSymmetricSecondRankTensorPython
import itkMatrixPython
import itkCovariantVectorPython
import vnl_vector_refPython
import vnl_vectorPython
import vnl_matrixPython
import itkVectorPython
import vnl_matrix_fixedPython
import itkPointPython
import itkRGBPixelPython
import itkImageToImageFilterCommonPython
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)

