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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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

def itkImageToImageFilterIF3ICVD33_New():
  return itkImageToImageFilterIF3ICVD33.New()


def itkImageToImageFilterIF2ICVD22_New():
  return itkImageToImageFilterIF2ICVD22.New()


def itkImageToImageFilterICF3ICF2_New():
  return itkImageToImageFilterICF3ICF2.New()


def itkImageToImageFilterIRGBUC3IRGBUC2_New():
  return itkImageToImageFilterIRGBUC3IRGBUC2.New()


def itkImageToImageFilterIF3IF2_New():
  return itkImageToImageFilterIF3IF2.New()


def itkImageToImageFilterIUC3IUC2_New():
  return itkImageToImageFilterIUC3IUC2.New()


def itkImageToImageFilterISS3ISS2_New():
  return itkImageToImageFilterISS3ISS2.New()


def itkImageToImageFilterICF2ICF3_New():
  return itkImageToImageFilterICF2ICF3.New()


def itkImageToImageFilterIRGBUC2IRGBUC3_New():
  return itkImageToImageFilterIRGBUC2IRGBUC3.New()


def itkImageToImageFilterIF2IF3_New():
  return itkImageToImageFilterIF2IF3.New()


def itkImageToImageFilterIUC2IUC3_New():
  return itkImageToImageFilterIUC2IUC3.New()


def itkImageToImageFilterISS2ISS3_New():
  return itkImageToImageFilterISS2ISS3.New()


def itkImageToImageFilterISSRTD33IF3_New():
  return itkImageToImageFilterISSRTD33IF3.New()


def itkImageToImageFilterIF3ISSRTD33_New():
  return itkImageToImageFilterIF3ISSRTD33.New()


def itkImageToImageFilterISSRTD33IUC3_New():
  return itkImageToImageFilterISSRTD33IUC3.New()


def itkImageToImageFilterIUC3ISSRTD33_New():
  return itkImageToImageFilterIUC3ISSRTD33.New()


def itkImageToImageFilterISSRTD33ISS3_New():
  return itkImageToImageFilterISSRTD33ISS3.New()


def itkImageToImageFilterISS3ISSRTD33_New():
  return itkImageToImageFilterISS3ISSRTD33.New()


def itkImageToImageFilterISSRTD22IF2_New():
  return itkImageToImageFilterISSRTD22IF2.New()


def itkImageToImageFilterIF2ISSRTD22_New():
  return itkImageToImageFilterIF2ISSRTD22.New()


def itkImageToImageFilterISSRTD22IUC2_New():
  return itkImageToImageFilterISSRTD22IUC2.New()


def itkImageToImageFilterIUC2ISSRTD22_New():
  return itkImageToImageFilterIUC2ISSRTD22.New()


def itkImageToImageFilterISSRTD22ISS2_New():
  return itkImageToImageFilterISSRTD22ISS2.New()


def itkImageToImageFilterISS2ISSRTD22_New():
  return itkImageToImageFilterISS2ISSRTD22.New()


def itkImageToImageFilterICF3IF3_New():
  return itkImageToImageFilterICF3IF3.New()


def itkImageToImageFilterICF2IF2_New():
  return itkImageToImageFilterICF2IF2.New()


def itkImageToImageFilterIF3ICF3_New():
  return itkImageToImageFilterIF3ICF3.New()


def itkImageToImageFilterIF2ICF2_New():
  return itkImageToImageFilterIF2ICF2.New()


def itkImageToImageFilterIF3ICVF43_New():
  return itkImageToImageFilterIF3ICVF43.New()


def itkImageToImageFilterIF2ICVF42_New():
  return itkImageToImageFilterIF2ICVF42.New()


def itkImageToImageFilterIF3ICVF33_New():
  return itkImageToImageFilterIF3ICVF33.New()


def itkImageToImageFilterIF2ICVF32_New():
  return itkImageToImageFilterIF2ICVF32.New()


def itkImageToImageFilterIF3ICVF23_New():
  return itkImageToImageFilterIF3ICVF23.New()


def itkImageToImageFilterIF2ICVF22_New():
  return itkImageToImageFilterIF2ICVF22.New()


def itkImageToImageFilterIF3IVF43_New():
  return itkImageToImageFilterIF3IVF43.New()


def itkImageToImageFilterIF2IVF42_New():
  return itkImageToImageFilterIF2IVF42.New()


def itkImageToImageFilterIF3IVF33_New():
  return itkImageToImageFilterIF3IVF33.New()


def itkImageToImageFilterIF2IVF32_New():
  return itkImageToImageFilterIF2IVF32.New()


def itkImageToImageFilterIF3IVF23_New():
  return itkImageToImageFilterIF3IVF23.New()


def itkImageToImageFilterIF2IVF22_New():
  return itkImageToImageFilterIF2IVF22.New()


def itkImageToImageFilterIUC3ICVF43_New():
  return itkImageToImageFilterIUC3ICVF43.New()


def itkImageToImageFilterIUC2ICVF42_New():
  return itkImageToImageFilterIUC2ICVF42.New()


def itkImageToImageFilterIUC3ICVF33_New():
  return itkImageToImageFilterIUC3ICVF33.New()


def itkImageToImageFilterIUC2ICVF32_New():
  return itkImageToImageFilterIUC2ICVF32.New()


def itkImageToImageFilterIUC3ICVF23_New():
  return itkImageToImageFilterIUC3ICVF23.New()


def itkImageToImageFilterIUC2ICVF22_New():
  return itkImageToImageFilterIUC2ICVF22.New()


def itkImageToImageFilterIUC3IVF43_New():
  return itkImageToImageFilterIUC3IVF43.New()


def itkImageToImageFilterIUC2IVF42_New():
  return itkImageToImageFilterIUC2IVF42.New()


def itkImageToImageFilterIUC3IVF33_New():
  return itkImageToImageFilterIUC3IVF33.New()


def itkImageToImageFilterIUC2IVF32_New():
  return itkImageToImageFilterIUC2IVF32.New()


def itkImageToImageFilterIUC3IVF23_New():
  return itkImageToImageFilterIUC3IVF23.New()


def itkImageToImageFilterIUC2IVF22_New():
  return itkImageToImageFilterIUC2IVF22.New()


def itkImageToImageFilterISS3ICVF43_New():
  return itkImageToImageFilterISS3ICVF43.New()


def itkImageToImageFilterISS2ICVF42_New():
  return itkImageToImageFilterISS2ICVF42.New()


def itkImageToImageFilterISS3ICVF33_New():
  return itkImageToImageFilterISS3ICVF33.New()


def itkImageToImageFilterISS2ICVF32_New():
  return itkImageToImageFilterISS2ICVF32.New()


def itkImageToImageFilterISS3ICVF23_New():
  return itkImageToImageFilterISS3ICVF23.New()


def itkImageToImageFilterISS2ICVF22_New():
  return itkImageToImageFilterISS2ICVF22.New()


def itkImageToImageFilterISS3IVF43_New():
  return itkImageToImageFilterISS3IVF43.New()


def itkImageToImageFilterISS2IVF42_New():
  return itkImageToImageFilterISS2IVF42.New()


def itkImageToImageFilterISS3IVF33_New():
  return itkImageToImageFilterISS3IVF33.New()


def itkImageToImageFilterISS2IVF32_New():
  return itkImageToImageFilterISS2IVF32.New()


def itkImageToImageFilterISS3IVF23_New():
  return itkImageToImageFilterISS3IVF23.New()


def itkImageToImageFilterISS2IVF22_New():
  return itkImageToImageFilterISS2IVF22.New()


def itkImageToImageFilterICVF43IF3_New():
  return itkImageToImageFilterICVF43IF3.New()


def itkImageToImageFilterICVF42IF2_New():
  return itkImageToImageFilterICVF42IF2.New()


def itkImageToImageFilterICVF33IF3_New():
  return itkImageToImageFilterICVF33IF3.New()


def itkImageToImageFilterICVF32IF2_New():
  return itkImageToImageFilterICVF32IF2.New()


def itkImageToImageFilterICVF23IF3_New():
  return itkImageToImageFilterICVF23IF3.New()


def itkImageToImageFilterICVF22IF2_New():
  return itkImageToImageFilterICVF22IF2.New()


def itkImageToImageFilterICVF43IUC3_New():
  return itkImageToImageFilterICVF43IUC3.New()


def itkImageToImageFilterICVF42IUC2_New():
  return itkImageToImageFilterICVF42IUC2.New()


def itkImageToImageFilterICVF33IUC3_New():
  return itkImageToImageFilterICVF33IUC3.New()


def itkImageToImageFilterICVF32IUC2_New():
  return itkImageToImageFilterICVF32IUC2.New()


def itkImageToImageFilterICVF23IUC3_New():
  return itkImageToImageFilterICVF23IUC3.New()


def itkImageToImageFilterICVF22IUC2_New():
  return itkImageToImageFilterICVF22IUC2.New()


def itkImageToImageFilterICVF43ISS3_New():
  return itkImageToImageFilterICVF43ISS3.New()


def itkImageToImageFilterICVF42ISS2_New():
  return itkImageToImageFilterICVF42ISS2.New()


def itkImageToImageFilterICVF33ISS3_New():
  return itkImageToImageFilterICVF33ISS3.New()


def itkImageToImageFilterICVF32ISS2_New():
  return itkImageToImageFilterICVF32ISS2.New()


def itkImageToImageFilterICVF23ISS3_New():
  return itkImageToImageFilterICVF23ISS3.New()


def itkImageToImageFilterICVF22ISS2_New():
  return itkImageToImageFilterICVF22ISS2.New()


def itkImageToImageFilterIVF43IF3_New():
  return itkImageToImageFilterIVF43IF3.New()


def itkImageToImageFilterIVF42IF2_New():
  return itkImageToImageFilterIVF42IF2.New()


def itkImageToImageFilterIVF33IF3_New():
  return itkImageToImageFilterIVF33IF3.New()


def itkImageToImageFilterIVF32IF2_New():
  return itkImageToImageFilterIVF32IF2.New()


def itkImageToImageFilterIVF23IF3_New():
  return itkImageToImageFilterIVF23IF3.New()


def itkImageToImageFilterIVF22IF2_New():
  return itkImageToImageFilterIVF22IF2.New()


def itkImageToImageFilterIVF43IUC3_New():
  return itkImageToImageFilterIVF43IUC3.New()


def itkImageToImageFilterIVF42IUC2_New():
  return itkImageToImageFilterIVF42IUC2.New()


def itkImageToImageFilterIVF33IUC3_New():
  return itkImageToImageFilterIVF33IUC3.New()


def itkImageToImageFilterIVF32IUC2_New():
  return itkImageToImageFilterIVF32IUC2.New()


def itkImageToImageFilterIVF23IUC3_New():
  return itkImageToImageFilterIVF23IUC3.New()


def itkImageToImageFilterIVF22IUC2_New():
  return itkImageToImageFilterIVF22IUC2.New()


def itkImageToImageFilterIVF43ISS3_New():
  return itkImageToImageFilterIVF43ISS3.New()


def itkImageToImageFilterIVF42ISS2_New():
  return itkImageToImageFilterIVF42ISS2.New()


def itkImageToImageFilterIVF33ISS3_New():
  return itkImageToImageFilterIVF33ISS3.New()


def itkImageToImageFilterIVF32ISS2_New():
  return itkImageToImageFilterIVF32ISS2.New()


def itkImageToImageFilterIVF23ISS3_New():
  return itkImageToImageFilterIVF23ISS3.New()


def itkImageToImageFilterIVF22ISS2_New():
  return itkImageToImageFilterIVF22ISS2.New()


def itkImageToImageFilterIF3VIF3_New():
  return itkImageToImageFilterIF3VIF3.New()


def itkImageToImageFilterVIF3IF3_New():
  return itkImageToImageFilterVIF3IF3.New()


def itkImageToImageFilterISS3VIF3_New():
  return itkImageToImageFilterISS3VIF3.New()


def itkImageToImageFilterVIF3ISS3_New():
  return itkImageToImageFilterVIF3ISS3.New()


def itkImageToImageFilterIUC3VIF3_New():
  return itkImageToImageFilterIUC3VIF3.New()


def itkImageToImageFilterVIF3IUC3_New():
  return itkImageToImageFilterVIF3IUC3.New()


def itkImageToImageFilterIF3VISS3_New():
  return itkImageToImageFilterIF3VISS3.New()


def itkImageToImageFilterVISS3IF3_New():
  return itkImageToImageFilterVISS3IF3.New()


def itkImageToImageFilterISS3VISS3_New():
  return itkImageToImageFilterISS3VISS3.New()


def itkImageToImageFilterVISS3ISS3_New():
  return itkImageToImageFilterVISS3ISS3.New()


def itkImageToImageFilterIUC3VISS3_New():
  return itkImageToImageFilterIUC3VISS3.New()


def itkImageToImageFilterVISS3IUC3_New():
  return itkImageToImageFilterVISS3IUC3.New()


def itkImageToImageFilterIF3VIUC3_New():
  return itkImageToImageFilterIF3VIUC3.New()


def itkImageToImageFilterVIUC3IF3_New():
  return itkImageToImageFilterVIUC3IF3.New()


def itkImageToImageFilterISS3VIUC3_New():
  return itkImageToImageFilterISS3VIUC3.New()


def itkImageToImageFilterVIUC3ISS3_New():
  return itkImageToImageFilterVIUC3ISS3.New()


def itkImageToImageFilterIUC3VIUC3_New():
  return itkImageToImageFilterIUC3VIUC3.New()


def itkImageToImageFilterVIUC3IUC3_New():
  return itkImageToImageFilterVIUC3IUC3.New()


def itkImageToImageFilterIF2VIF2_New():
  return itkImageToImageFilterIF2VIF2.New()


def itkImageToImageFilterVIF2IF2_New():
  return itkImageToImageFilterVIF2IF2.New()


def itkImageToImageFilterISS2VIF2_New():
  return itkImageToImageFilterISS2VIF2.New()


def itkImageToImageFilterVIF2ISS2_New():
  return itkImageToImageFilterVIF2ISS2.New()


def itkImageToImageFilterIUC2VIF2_New():
  return itkImageToImageFilterIUC2VIF2.New()


def itkImageToImageFilterVIF2IUC2_New():
  return itkImageToImageFilterVIF2IUC2.New()


def itkImageToImageFilterIF2VISS2_New():
  return itkImageToImageFilterIF2VISS2.New()


def itkImageToImageFilterVISS2IF2_New():
  return itkImageToImageFilterVISS2IF2.New()


def itkImageToImageFilterISS2VISS2_New():
  return itkImageToImageFilterISS2VISS2.New()


def itkImageToImageFilterVISS2ISS2_New():
  return itkImageToImageFilterVISS2ISS2.New()


def itkImageToImageFilterIUC2VISS2_New():
  return itkImageToImageFilterIUC2VISS2.New()


def itkImageToImageFilterVISS2IUC2_New():
  return itkImageToImageFilterVISS2IUC2.New()


def itkImageToImageFilterIF2VIUC2_New():
  return itkImageToImageFilterIF2VIUC2.New()


def itkImageToImageFilterVIUC2IF2_New():
  return itkImageToImageFilterVIUC2IF2.New()


def itkImageToImageFilterISS2VIUC2_New():
  return itkImageToImageFilterISS2VIUC2.New()


def itkImageToImageFilterVIUC2ISS2_New():
  return itkImageToImageFilterVIUC2ISS2.New()


def itkImageToImageFilterIUC2VIUC2_New():
  return itkImageToImageFilterIUC2VIUC2.New()


def itkImageToImageFilterVIUC2IUC2_New():
  return itkImageToImageFilterVIUC2IUC2.New()


def itkImageToImageFilterIRGBAUC3IF3_New():
  return itkImageToImageFilterIRGBAUC3IF3.New()


def itkImageToImageFilterIRGBAUC2IF2_New():
  return itkImageToImageFilterIRGBAUC2IF2.New()


def itkImageToImageFilterIRGBAUC3IUC3_New():
  return itkImageToImageFilterIRGBAUC3IUC3.New()


def itkImageToImageFilterIRGBAUC2IUC2_New():
  return itkImageToImageFilterIRGBAUC2IUC2.New()


def itkImageToImageFilterIRGBAUC3ISS3_New():
  return itkImageToImageFilterIRGBAUC3ISS3.New()


def itkImageToImageFilterIRGBAUC2ISS2_New():
  return itkImageToImageFilterIRGBAUC2ISS2.New()


def itkImageToImageFilterIRGBAUC3IUL3_New():
  return itkImageToImageFilterIRGBAUC3IUL3.New()


def itkImageToImageFilterIRGBAUC2IUL2_New():
  return itkImageToImageFilterIRGBAUC2IUL2.New()


def itkImageToImageFilterIF3IRGBAUC3_New():
  return itkImageToImageFilterIF3IRGBAUC3.New()


def itkImageToImageFilterIF2IRGBAUC2_New():
  return itkImageToImageFilterIF2IRGBAUC2.New()


def itkImageToImageFilterIUC3IRGBAUC3_New():
  return itkImageToImageFilterIUC3IRGBAUC3.New()


def itkImageToImageFilterIUC2IRGBAUC2_New():
  return itkImageToImageFilterIUC2IRGBAUC2.New()


def itkImageToImageFilterISS3IRGBAUC3_New():
  return itkImageToImageFilterISS3IRGBAUC3.New()


def itkImageToImageFilterISS2IRGBAUC2_New():
  return itkImageToImageFilterISS2IRGBAUC2.New()


def itkImageToImageFilterIUL3IRGBAUC3_New():
  return itkImageToImageFilterIUL3IRGBAUC3.New()


def itkImageToImageFilterIUL2IRGBAUC2_New():
  return itkImageToImageFilterIUL2IRGBAUC2.New()


def itkImageToImageFilterIRGBUC3IF3_New():
  return itkImageToImageFilterIRGBUC3IF3.New()


def itkImageToImageFilterIRGBUC2IF2_New():
  return itkImageToImageFilterIRGBUC2IF2.New()


def itkImageToImageFilterIRGBUC3IUC3_New():
  return itkImageToImageFilterIRGBUC3IUC3.New()


def itkImageToImageFilterIRGBUC2IUC2_New():
  return itkImageToImageFilterIRGBUC2IUC2.New()


def itkImageToImageFilterIRGBUC3ISS3_New():
  return itkImageToImageFilterIRGBUC3ISS3.New()


def itkImageToImageFilterIRGBUC2ISS2_New():
  return itkImageToImageFilterIRGBUC2ISS2.New()


def itkImageToImageFilterIRGBUC3IUL3_New():
  return itkImageToImageFilterIRGBUC3IUL3.New()


def itkImageToImageFilterIRGBUC2IUL2_New():
  return itkImageToImageFilterIRGBUC2IUL2.New()


def itkImageToImageFilterIF3IRGBUC3_New():
  return itkImageToImageFilterIF3IRGBUC3.New()


def itkImageToImageFilterIF2IRGBUC2_New():
  return itkImageToImageFilterIF2IRGBUC2.New()


def itkImageToImageFilterIUC3IRGBUC3_New():
  return itkImageToImageFilterIUC3IRGBUC3.New()


def itkImageToImageFilterIUC2IRGBUC2_New():
  return itkImageToImageFilterIUC2IRGBUC2.New()


def itkImageToImageFilterISS3IRGBUC3_New():
  return itkImageToImageFilterISS3IRGBUC3.New()


def itkImageToImageFilterISS2IRGBUC2_New():
  return itkImageToImageFilterISS2IRGBUC2.New()


def itkImageToImageFilterIUL3IRGBUC3_New():
  return itkImageToImageFilterIUL3IRGBUC3.New()


def itkImageToImageFilterIUL2IRGBUC2_New():
  return itkImageToImageFilterIUL2IRGBUC2.New()


def itkImageToImageFilterICF3ICF3_New():
  return itkImageToImageFilterICF3ICF3.New()


def itkImageToImageFilterICF2ICF2_New():
  return itkImageToImageFilterICF2ICF2.New()

class itkImageToImageFilterICF2ICF2(itkImageSourcePython.itkImageSourceICF2):
    r"""Proxy of C++ itkImageToImageFilterICF2ICF2 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(_itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterICF2ICF2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF2_GetPointer)

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

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

          itkImageToImageFilterICF2ICF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICF2ICF2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF2_swigregister(itkImageToImageFilterICF2ICF2)
class itkImageToImageFilterICF2ICF3(itkImageSourcePython.itkImageSourceICF3):
    r"""Proxy of C++ itkImageToImageFilterICF2ICF3 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(_itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterICF2ICF3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF3_GetPointer)

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

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

          itkImageToImageFilterICF2ICF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICF2ICF3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF3_swigregister(itkImageToImageFilterICF2ICF3)
class itkImageToImageFilterICF2IF2(itkImageSourcePython.itkImageSourceIF2):
    r"""Proxy of C++ itkImageToImageFilterICF2IF2 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(_itkImageToImageFilterBPython.itkImageToImageFilterICF2IF2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2IF2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2IF2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2IF2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2IF2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2IF2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2IF2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2IF2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2IF2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2IF2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterICF2IF2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2IF2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF2IF2_GetPointer)

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

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

          itkImageToImageFilterICF2IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICF2IF2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterICF2IF2_swigregister(itkImageToImageFilterICF2IF2)
class itkImageToImageFilterICF3ICF2(itkImageSourcePython.itkImageSourceICF2):
    r"""Proxy of C++ itkImageToImageFilterICF3ICF2 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(_itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterICF3ICF2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF2_GetPointer)

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

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

          itkImageToImageFilterICF3ICF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICF3ICF2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF2_swigregister(itkImageToImageFilterICF3ICF2)
class itkImageToImageFilterICF3ICF3(itkImageSourcePython.itkImageSourceICF3):
    r"""Proxy of C++ itkImageToImageFilterICF3ICF3 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(_itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterICF3ICF3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF3_GetPointer)

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

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

          itkImageToImageFilterICF3ICF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICF3ICF3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF3_swigregister(itkImageToImageFilterICF3ICF3)
class itkImageToImageFilterICF3IF3(itkImageSourcePython.itkImageSourceIF3):
    r"""Proxy of C++ itkImageToImageFilterICF3IF3 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(_itkImageToImageFilterBPython.itkImageToImageFilterICF3IF3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3IF3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3IF3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3IF3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3IF3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3IF3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3IF3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3IF3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3IF3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3IF3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterICF3IF3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3IF3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICF3IF3_GetPointer)

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

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

          itkImageToImageFilterICF3IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICF3IF3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterICF3IF3_swigregister(itkImageToImageFilterICF3IF3)
class itkImageToImageFilterICVF22IF2(itkImageSourcePython.itkImageSourceIF2):
    r"""Proxy of C++ itkImageToImageFilterICVF22IF2 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(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22IF2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22IF2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22IF2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22IF2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22IF2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22IF2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22IF2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22IF2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22IF2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22IF2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterICVF22IF2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22IF2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22IF2_GetPointer)

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

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

          itkImageToImageFilterICVF22IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF22IF2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterICVF22IF2_swigregister(itkImageToImageFilterICVF22IF2)
class itkImageToImageFilterICVF22ISS2(itkImageSourcePython.itkImageSourceISS2):
    r"""Proxy of C++ itkImageToImageFilterICVF22ISS2 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(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22ISS2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22ISS2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22ISS2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22ISS2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22ISS2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22ISS2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22ISS2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22ISS2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22ISS2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22ISS2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterICVF22ISS2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22ISS2_GetPointer)

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

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

          itkImageToImageFilterICVF22ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF22ISS2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterICVF22ISS2_swigregister(itkImageToImageFilterICVF22ISS2)
class itkImageToImageFilterICVF22IUC2(itkImageSourcePython.itkImageSourceIUC2):
    r"""Proxy of C++ itkImageToImageFilterICVF22IUC2 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(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22IUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22IUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22IUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22IUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22IUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22IUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22IUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22IUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22IUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22IUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterICVF22IUC2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF22IUC2_GetPointer)

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

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

          itkImageToImageFilterICVF22IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF22IUC2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterICVF22IUC2_swigregister(itkImageToImageFilterICVF22IUC2)
class itkImageToImageFilterICVF23IF3(itkImageSourcePython.itkImageSourceIF3):
    r"""Proxy of C++ itkImageToImageFilterICVF23IF3 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(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23IF3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23IF3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23IF3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23IF3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23IF3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23IF3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23IF3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23IF3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23IF3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23IF3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterICVF23IF3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23IF3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23IF3_GetPointer)

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

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

          itkImageToImageFilterICVF23IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF23IF3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterICVF23IF3_swigregister(itkImageToImageFilterICVF23IF3)
class itkImageToImageFilterICVF23ISS3(itkImageSourcePython.itkImageSourceISS3):
    r"""Proxy of C++ itkImageToImageFilterICVF23ISS3 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(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23ISS3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23ISS3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23ISS3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23ISS3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23ISS3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23ISS3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23ISS3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23ISS3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23ISS3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23ISS3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterICVF23ISS3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23ISS3_GetPointer)

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

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

          itkImageToImageFilterICVF23ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF23ISS3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterICVF23ISS3_swigregister(itkImageToImageFilterICVF23ISS3)
class itkImageToImageFilterICVF23IUC3(itkImageSourcePython.itkImageSourceIUC3):
    r"""Proxy of C++ itkImageToImageFilterICVF23IUC3 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(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23IUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23IUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23IUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23IUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23IUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23IUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23IUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23IUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23IUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23IUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterICVF23IUC3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF23IUC3_GetPointer)

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

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

          itkImageToImageFilterICVF23IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF23IUC3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterICVF23IUC3_swigregister(itkImageToImageFilterICVF23IUC3)
class itkImageToImageFilterICVF32IF2(itkImageSourcePython.itkImageSourceIF2):
    r"""Proxy of C++ itkImageToImageFilterICVF32IF2 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(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32IF2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32IF2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32IF2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32IF2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32IF2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32IF2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32IF2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32IF2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32IF2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32IF2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterICVF32IF2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32IF2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32IF2_GetPointer)

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

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

          itkImageToImageFilterICVF32IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF32IF2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterICVF32IF2_swigregister(itkImageToImageFilterICVF32IF2)
class itkImageToImageFilterICVF32ISS2(itkImageSourcePython.itkImageSourceISS2):
    r"""Proxy of C++ itkImageToImageFilterICVF32ISS2 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(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32ISS2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32ISS2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32ISS2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32ISS2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32ISS2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32ISS2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32ISS2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32ISS2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32ISS2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32ISS2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterICVF32ISS2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32ISS2_GetPointer)

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

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

          itkImageToImageFilterICVF32ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF32ISS2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterICVF32ISS2_swigregister(itkImageToImageFilterICVF32ISS2)
class itkImageToImageFilterICVF32IUC2(itkImageSourcePython.itkImageSourceIUC2):
    r"""Proxy of C++ itkImageToImageFilterICVF32IUC2 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(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32IUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32IUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32IUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32IUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32IUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32IUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32IUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32IUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32IUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32IUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterICVF32IUC2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF32IUC2_GetPointer)

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

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

          itkImageToImageFilterICVF32IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF32IUC2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterICVF32IUC2_swigregister(itkImageToImageFilterICVF32IUC2)
class itkImageToImageFilterICVF33IF3(itkImageSourcePython.itkImageSourceIF3):
    r"""Proxy of C++ itkImageToImageFilterICVF33IF3 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(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33IF3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33IF3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33IF3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33IF3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33IF3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33IF3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33IF3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33IF3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33IF3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33IF3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterICVF33IF3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33IF3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33IF3_GetPointer)

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

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

          itkImageToImageFilterICVF33IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF33IF3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterICVF33IF3_swigregister(itkImageToImageFilterICVF33IF3)
class itkImageToImageFilterICVF33ISS3(itkImageSourcePython.itkImageSourceISS3):
    r"""Proxy of C++ itkImageToImageFilterICVF33ISS3 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(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33ISS3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33ISS3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33ISS3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33ISS3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33ISS3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33ISS3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33ISS3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33ISS3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33ISS3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33ISS3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterICVF33ISS3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33ISS3_GetPointer)

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

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

          itkImageToImageFilterICVF33ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF33ISS3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterICVF33ISS3_swigregister(itkImageToImageFilterICVF33ISS3)
class itkImageToImageFilterICVF33IUC3(itkImageSourcePython.itkImageSourceIUC3):
    r"""Proxy of C++ itkImageToImageFilterICVF33IUC3 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(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33IUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33IUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33IUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33IUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33IUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33IUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33IUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33IUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33IUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33IUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterICVF33IUC3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF33IUC3_GetPointer)

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

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

          itkImageToImageFilterICVF33IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF33IUC3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterICVF33IUC3_swigregister(itkImageToImageFilterICVF33IUC3)
class itkImageToImageFilterICVF42IF2(itkImageSourcePython.itkImageSourceIF2):
    r"""Proxy of C++ itkImageToImageFilterICVF42IF2 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(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42IF2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42IF2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42IF2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42IF2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42IF2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42IF2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42IF2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42IF2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42IF2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42IF2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterICVF42IF2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42IF2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42IF2_GetPointer)

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

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

          itkImageToImageFilterICVF42IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF42IF2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterICVF42IF2_swigregister(itkImageToImageFilterICVF42IF2)
class itkImageToImageFilterICVF42ISS2(itkImageSourcePython.itkImageSourceISS2):
    r"""Proxy of C++ itkImageToImageFilterICVF42ISS2 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(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42ISS2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42ISS2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42ISS2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42ISS2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42ISS2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42ISS2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42ISS2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42ISS2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42ISS2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42ISS2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterICVF42ISS2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42ISS2_GetPointer)

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

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

          itkImageToImageFilterICVF42ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF42ISS2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterICVF42ISS2_swigregister(itkImageToImageFilterICVF42ISS2)
class itkImageToImageFilterICVF42IUC2(itkImageSourcePython.itkImageSourceIUC2):
    r"""Proxy of C++ itkImageToImageFilterICVF42IUC2 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(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42IUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42IUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42IUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42IUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42IUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42IUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42IUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42IUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42IUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42IUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterICVF42IUC2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF42IUC2_GetPointer)

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

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

          itkImageToImageFilterICVF42IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF42IUC2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterICVF42IUC2_swigregister(itkImageToImageFilterICVF42IUC2)
class itkImageToImageFilterICVF43IF3(itkImageSourcePython.itkImageSourceIF3):
    r"""Proxy of C++ itkImageToImageFilterICVF43IF3 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(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43IF3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43IF3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43IF3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43IF3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43IF3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43IF3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43IF3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43IF3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43IF3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43IF3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterICVF43IF3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43IF3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43IF3_GetPointer)

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

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

          itkImageToImageFilterICVF43IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF43IF3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterICVF43IF3_swigregister(itkImageToImageFilterICVF43IF3)
class itkImageToImageFilterICVF43ISS3(itkImageSourcePython.itkImageSourceISS3):
    r"""Proxy of C++ itkImageToImageFilterICVF43ISS3 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(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43ISS3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43ISS3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43ISS3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43ISS3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43ISS3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43ISS3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43ISS3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43ISS3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43ISS3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43ISS3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterICVF43ISS3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43ISS3_GetPointer)

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

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

          itkImageToImageFilterICVF43ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF43ISS3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterICVF43ISS3_swigregister(itkImageToImageFilterICVF43ISS3)
class itkImageToImageFilterICVF43IUC3(itkImageSourcePython.itkImageSourceIUC3):
    r"""Proxy of C++ itkImageToImageFilterICVF43IUC3 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(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43IUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43IUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43IUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43IUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43IUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43IUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43IUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43IUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43IUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43IUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterICVF43IUC3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterICVF43IUC3_GetPointer)

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

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

          itkImageToImageFilterICVF43IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterICVF43IUC3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterICVF43IUC3_swigregister(itkImageToImageFilterICVF43IUC3)
class itkImageToImageFilterIF2ICF2(itkImageSourcePython.itkImageSourceICF2):
    r"""Proxy of C++ itkImageToImageFilterIF2ICF2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICF2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICF2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICF2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICF2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICF2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICF2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICF2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICF2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICF2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICF2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF2ICF2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICF2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICF2_GetPointer)

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

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

          itkImageToImageFilterIF2ICF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF2ICF2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICF2_swigregister(itkImageToImageFilterIF2ICF2)
class itkImageToImageFilterIF2ICVD22(itkImageSourcePython.itkImageSourceICVD22):
    r"""Proxy of C++ itkImageToImageFilterIF2ICVD22 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVD22_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVD22_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVD22_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVD22_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVD22_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVD22_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVD22_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVD22_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVD22_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVD22_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF2ICVD22
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVD22_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVD22_GetPointer)

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

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

          itkImageToImageFilterIF2ICVD22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF2ICVD22 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVD22_swigregister(itkImageToImageFilterIF2ICVD22)
class itkImageToImageFilterIF2ICVF22(itkImageSourcePython.itkImageSourceICVF22):
    r"""Proxy of C++ itkImageToImageFilterIF2ICVF22 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF22_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF22_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF22_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF22_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF22_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF22_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF22_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF22_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF22_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF22_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF2ICVF22
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF22_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF22_GetPointer)

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

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

          itkImageToImageFilterIF2ICVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF2ICVF22 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF22_swigregister(itkImageToImageFilterIF2ICVF22)
class itkImageToImageFilterIF2ICVF32(itkImageSourcePython.itkImageSourceICVF32):
    r"""Proxy of C++ itkImageToImageFilterIF2ICVF32 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF32_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF32_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF32_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF32_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF32_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF32_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF32_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF32_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF32_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF32_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF2ICVF32
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF32_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF32_GetPointer)

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

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

          itkImageToImageFilterIF2ICVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF2ICVF32 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF32_swigregister(itkImageToImageFilterIF2ICVF32)
class itkImageToImageFilterIF2ICVF42(itkImageSourcePython.itkImageSourceICVF42):
    r"""Proxy of C++ itkImageToImageFilterIF2ICVF42 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF42_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF42_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF42_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF42_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF42_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF42_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF42_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF42_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF42_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF42_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF2ICVF42
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF42_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF42_GetPointer)

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

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

          itkImageToImageFilterIF2ICVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF2ICVF42 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF42_swigregister(itkImageToImageFilterIF2ICVF42)
class itkImageToImageFilterIF2IF3(itkImageSourcePython.itkImageSourceIF3):
    r"""Proxy of C++ itkImageToImageFilterIF2IF3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IF3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IF3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IF3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IF3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IF3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IF3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IF3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IF3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IF3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IF3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF2IF3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IF3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IF3_GetPointer)

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

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

          itkImageToImageFilterIF2IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF2IF3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF2IF3_swigregister(itkImageToImageFilterIF2IF3)
class itkImageToImageFilterIF2IRGBAUC2(itkImageSourcePython.itkImageSourceIRGBAUC2):
    r"""Proxy of C++ itkImageToImageFilterIF2IRGBAUC2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBAUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBAUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBAUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBAUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBAUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBAUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBAUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBAUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBAUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBAUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF2IRGBAUC2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBAUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBAUC2_GetPointer)

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

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

          itkImageToImageFilterIF2IRGBAUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF2IRGBAUC2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBAUC2_swigregister(itkImageToImageFilterIF2IRGBAUC2)
class itkImageToImageFilterIF2IRGBUC2(itkImageSourcePython.itkImageSourceIRGBUC2):
    r"""Proxy of C++ itkImageToImageFilterIF2IRGBUC2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF2IRGBUC2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBUC2_GetPointer)

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

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

          itkImageToImageFilterIF2IRGBUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF2IRGBUC2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBUC2_swigregister(itkImageToImageFilterIF2IRGBUC2)
class itkImageToImageFilterIF2ISSRTD22(itkImageSourcePython.itkImageSourceISSRTD22):
    r"""Proxy of C++ itkImageToImageFilterIF2ISSRTD22 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ISSRTD22_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ISSRTD22_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ISSRTD22_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ISSRTD22_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ISSRTD22_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ISSRTD22_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ISSRTD22_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ISSRTD22_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ISSRTD22_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ISSRTD22_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF2ISSRTD22
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ISSRTD22_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2ISSRTD22_GetPointer)

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

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

          itkImageToImageFilterIF2ISSRTD22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF2ISSRTD22 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF2ISSRTD22_swigregister(itkImageToImageFilterIF2ISSRTD22)
class itkImageToImageFilterIF2IVF22(itkImageSourcePython.itkImageSourceIVF22):
    r"""Proxy of C++ itkImageToImageFilterIF2IVF22 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF22_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF22_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF22_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF22_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF22_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF22_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF22_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF22_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF22_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF22_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF2IVF22
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF22_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF22_GetPointer)

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

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

          itkImageToImageFilterIF2IVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF2IVF22 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF22_swigregister(itkImageToImageFilterIF2IVF22)
class itkImageToImageFilterIF2IVF32(itkImageSourcePython.itkImageSourceIVF32):
    r"""Proxy of C++ itkImageToImageFilterIF2IVF32 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF32_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF32_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF32_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF32_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF32_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF32_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF32_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF32_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF32_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF32_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF2IVF32
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF32_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF32_GetPointer)

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

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

          itkImageToImageFilterIF2IVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF2IVF32 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF32_swigregister(itkImageToImageFilterIF2IVF32)
class itkImageToImageFilterIF2IVF42(itkImageSourcePython.itkImageSourceIVF42):
    r"""Proxy of C++ itkImageToImageFilterIF2IVF42 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF42_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF42_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF42_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF42_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF42_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF42_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF42_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF42_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF42_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF42_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF2IVF42
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF42_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF42_GetPointer)

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

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

          itkImageToImageFilterIF2IVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF2IVF42 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF42_swigregister(itkImageToImageFilterIF2IVF42)
class itkImageToImageFilterIF2VIF2(itkImageSourcePython.itkImageSourceVIF2):
    r"""Proxy of C++ itkImageToImageFilterIF2VIF2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VIF2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VIF2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VIF2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VIF2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VIF2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VIF2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VIF2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VIF2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VIF2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VIF2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF2VIF2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VIF2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VIF2_GetPointer)

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

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

          itkImageToImageFilterIF2VIF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF2VIF2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF2VIF2_swigregister(itkImageToImageFilterIF2VIF2)
class itkImageToImageFilterIF2VISS2(itkImageSourcePython.itkImageSourceVISS2):
    r"""Proxy of C++ itkImageToImageFilterIF2VISS2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VISS2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VISS2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VISS2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VISS2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VISS2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VISS2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VISS2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VISS2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VISS2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VISS2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF2VISS2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VISS2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VISS2_GetPointer)

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

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

          itkImageToImageFilterIF2VISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF2VISS2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF2VISS2_swigregister(itkImageToImageFilterIF2VISS2)
class itkImageToImageFilterIF2VIUC2(itkImageSourcePython.itkImageSourceVIUC2):
    r"""Proxy of C++ itkImageToImageFilterIF2VIUC2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VIUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VIUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VIUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VIUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VIUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VIUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VIUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VIUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VIUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VIUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF2VIUC2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VIUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF2VIUC2_GetPointer)

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

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

          itkImageToImageFilterIF2VIUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF2VIUC2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF2VIUC2_swigregister(itkImageToImageFilterIF2VIUC2)
class itkImageToImageFilterIF3ICF3(itkImageSourcePython.itkImageSourceICF3):
    r"""Proxy of C++ itkImageToImageFilterIF3ICF3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICF3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICF3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICF3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICF3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICF3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICF3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICF3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICF3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICF3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICF3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF3ICF3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICF3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICF3_GetPointer)

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

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

          itkImageToImageFilterIF3ICF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF3ICF3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICF3_swigregister(itkImageToImageFilterIF3ICF3)
class itkImageToImageFilterIF3ICVD33(itkImageSourcePython.itkImageSourceICVD33):
    r"""Proxy of C++ itkImageToImageFilterIF3ICVD33 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVD33_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVD33_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVD33_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVD33_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVD33_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVD33_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVD33_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVD33_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVD33_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVD33_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF3ICVD33
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVD33_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVD33_GetPointer)

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

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

          itkImageToImageFilterIF3ICVD33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF3ICVD33 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVD33_swigregister(itkImageToImageFilterIF3ICVD33)
class itkImageToImageFilterIF3ICVF23(itkImageSourcePython.itkImageSourceICVF23):
    r"""Proxy of C++ itkImageToImageFilterIF3ICVF23 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF23_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF23_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF23_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF23_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF23_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF23_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF23_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF23_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF23_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF23_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF3ICVF23
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF23_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF23_GetPointer)

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

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

          itkImageToImageFilterIF3ICVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF3ICVF23 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF23_swigregister(itkImageToImageFilterIF3ICVF23)
class itkImageToImageFilterIF3ICVF33(itkImageSourcePython.itkImageSourceICVF33):
    r"""Proxy of C++ itkImageToImageFilterIF3ICVF33 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF33_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF33_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF33_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF33_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF33_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF33_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF33_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF33_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF33_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF33_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF3ICVF33
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF33_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF33_GetPointer)

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

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

          itkImageToImageFilterIF3ICVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF3ICVF33 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF33_swigregister(itkImageToImageFilterIF3ICVF33)
class itkImageToImageFilterIF3ICVF43(itkImageSourcePython.itkImageSourceICVF43):
    r"""Proxy of C++ itkImageToImageFilterIF3ICVF43 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF43_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF43_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF43_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF43_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF43_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF43_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF43_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF43_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF43_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF43_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF3ICVF43
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF43_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF43_GetPointer)

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

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

          itkImageToImageFilterIF3ICVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF3ICVF43 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF43_swigregister(itkImageToImageFilterIF3ICVF43)
class itkImageToImageFilterIF3IF2(itkImageSourcePython.itkImageSourceIF2):
    r"""Proxy of C++ itkImageToImageFilterIF3IF2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IF2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IF2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IF2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IF2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IF2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IF2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IF2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IF2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IF2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IF2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF3IF2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IF2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IF2_GetPointer)

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

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

          itkImageToImageFilterIF3IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF3IF2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF3IF2_swigregister(itkImageToImageFilterIF3IF2)
class itkImageToImageFilterIF3IRGBAUC3(itkImageSourcePython.itkImageSourceIRGBAUC3):
    r"""Proxy of C++ itkImageToImageFilterIF3IRGBAUC3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBAUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBAUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBAUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBAUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBAUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBAUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBAUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBAUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBAUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBAUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF3IRGBAUC3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBAUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBAUC3_GetPointer)

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

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

          itkImageToImageFilterIF3IRGBAUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF3IRGBAUC3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBAUC3_swigregister(itkImageToImageFilterIF3IRGBAUC3)
class itkImageToImageFilterIF3IRGBUC3(itkImageSourcePython.itkImageSourceIRGBUC3):
    r"""Proxy of C++ itkImageToImageFilterIF3IRGBUC3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF3IRGBUC3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBUC3_GetPointer)

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

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

          itkImageToImageFilterIF3IRGBUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF3IRGBUC3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBUC3_swigregister(itkImageToImageFilterIF3IRGBUC3)
class itkImageToImageFilterIF3ISSRTD33(itkImageSourcePython.itkImageSourceISSRTD33):
    r"""Proxy of C++ itkImageToImageFilterIF3ISSRTD33 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ISSRTD33_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ISSRTD33_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ISSRTD33_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ISSRTD33_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ISSRTD33_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ISSRTD33_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ISSRTD33_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ISSRTD33_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ISSRTD33_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ISSRTD33_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF3ISSRTD33
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ISSRTD33_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3ISSRTD33_GetPointer)

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

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

          itkImageToImageFilterIF3ISSRTD33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF3ISSRTD33 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF3ISSRTD33_swigregister(itkImageToImageFilterIF3ISSRTD33)
class itkImageToImageFilterIF3IVF23(itkImageSourcePython.itkImageSourceIVF23):
    r"""Proxy of C++ itkImageToImageFilterIF3IVF23 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF23_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF23_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF23_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF23_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF23_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF23_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF23_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF23_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF23_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF23_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF3IVF23
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF23_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF23_GetPointer)

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

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

          itkImageToImageFilterIF3IVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF3IVF23 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF23_swigregister(itkImageToImageFilterIF3IVF23)
class itkImageToImageFilterIF3IVF33(itkImageSourcePython.itkImageSourceIVF33):
    r"""Proxy of C++ itkImageToImageFilterIF3IVF33 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF33_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF33_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF33_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF33_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF33_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF33_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF33_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF33_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF33_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF33_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF3IVF33
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF33_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF33_GetPointer)

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

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

          itkImageToImageFilterIF3IVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF3IVF33 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF33_swigregister(itkImageToImageFilterIF3IVF33)
class itkImageToImageFilterIF3IVF43(itkImageSourcePython.itkImageSourceIVF43):
    r"""Proxy of C++ itkImageToImageFilterIF3IVF43 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF43_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF43_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF43_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF43_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF43_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF43_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF43_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF43_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF43_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF43_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF3IVF43
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF43_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF43_GetPointer)

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

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

          itkImageToImageFilterIF3IVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF3IVF43 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF43_swigregister(itkImageToImageFilterIF3IVF43)
class itkImageToImageFilterIF3VIF3(itkImageSourcePython.itkImageSourceVIF3):
    r"""Proxy of C++ itkImageToImageFilterIF3VIF3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VIF3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VIF3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VIF3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VIF3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VIF3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VIF3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VIF3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VIF3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VIF3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VIF3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF3VIF3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VIF3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VIF3_GetPointer)

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

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

          itkImageToImageFilterIF3VIF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF3VIF3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF3VIF3_swigregister(itkImageToImageFilterIF3VIF3)
class itkImageToImageFilterIF3VISS3(itkImageSourcePython.itkImageSourceVISS3):
    r"""Proxy of C++ itkImageToImageFilterIF3VISS3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VISS3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VISS3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VISS3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VISS3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VISS3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VISS3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VISS3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VISS3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VISS3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VISS3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF3VISS3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VISS3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VISS3_GetPointer)

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

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

          itkImageToImageFilterIF3VISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF3VISS3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF3VISS3_swigregister(itkImageToImageFilterIF3VISS3)
class itkImageToImageFilterIF3VIUC3(itkImageSourcePython.itkImageSourceVIUC3):
    r"""Proxy of C++ itkImageToImageFilterIF3VIUC3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VIUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VIUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VIUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VIUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VIUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VIUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VIUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VIUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VIUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VIUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIF3VIUC3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VIUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIF3VIUC3_GetPointer)

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

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

          itkImageToImageFilterIF3VIUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIF3VIUC3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIF3VIUC3_swigregister(itkImageToImageFilterIF3VIUC3)
class itkImageToImageFilterIRGBAUC2IF2(itkImageSourcePython.itkImageSourceIF2):
    r"""Proxy of C++ itkImageToImageFilterIRGBAUC2IF2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IF2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IF2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IF2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IF2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IF2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IF2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IF2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IF2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IF2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IF2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIRGBAUC2IF2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IF2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IF2_GetPointer)

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

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

          itkImageToImageFilterIRGBAUC2IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIRGBAUC2IF2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IF2_swigregister(itkImageToImageFilterIRGBAUC2IF2)
class itkImageToImageFilterIRGBAUC2ISS2(itkImageSourcePython.itkImageSourceISS2):
    r"""Proxy of C++ itkImageToImageFilterIRGBAUC2ISS2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2ISS2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2ISS2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2ISS2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2ISS2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2ISS2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2ISS2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2ISS2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2ISS2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2ISS2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2ISS2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIRGBAUC2ISS2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2ISS2_GetPointer)

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

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

          itkImageToImageFilterIRGBAUC2ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIRGBAUC2ISS2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2ISS2_swigregister(itkImageToImageFilterIRGBAUC2ISS2)
class itkImageToImageFilterIRGBAUC2IUC2(itkImageSourcePython.itkImageSourceIUC2):
    r"""Proxy of C++ itkImageToImageFilterIRGBAUC2IUC2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIRGBAUC2IUC2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUC2_GetPointer)

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

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

          itkImageToImageFilterIRGBAUC2IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIRGBAUC2IUC2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUC2_swigregister(itkImageToImageFilterIRGBAUC2IUC2)
class itkImageToImageFilterIRGBAUC2IUL2(itkImageSourcePython.itkImageSourceIUL2):
    r"""Proxy of C++ itkImageToImageFilterIRGBAUC2IUL2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUL2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUL2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUL2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUL2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUL2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUL2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUL2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUL2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUL2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUL2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIRGBAUC2IUL2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUL2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUL2_GetPointer)

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

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

          itkImageToImageFilterIRGBAUC2IUL2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIRGBAUC2IUL2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUL2_swigregister(itkImageToImageFilterIRGBAUC2IUL2)
class itkImageToImageFilterIRGBAUC3IF3(itkImageSourcePython.itkImageSourceIF3):
    r"""Proxy of C++ itkImageToImageFilterIRGBAUC3IF3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IF3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IF3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IF3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IF3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IF3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IF3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IF3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IF3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IF3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IF3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIRGBAUC3IF3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IF3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IF3_GetPointer)

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

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

          itkImageToImageFilterIRGBAUC3IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIRGBAUC3IF3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IF3_swigregister(itkImageToImageFilterIRGBAUC3IF3)
class itkImageToImageFilterIRGBAUC3ISS3(itkImageSourcePython.itkImageSourceISS3):
    r"""Proxy of C++ itkImageToImageFilterIRGBAUC3ISS3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3ISS3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3ISS3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3ISS3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3ISS3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3ISS3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3ISS3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3ISS3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3ISS3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3ISS3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3ISS3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIRGBAUC3ISS3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3ISS3_GetPointer)

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

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

          itkImageToImageFilterIRGBAUC3ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIRGBAUC3ISS3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3ISS3_swigregister(itkImageToImageFilterIRGBAUC3ISS3)
class itkImageToImageFilterIRGBAUC3IUC3(itkImageSourcePython.itkImageSourceIUC3):
    r"""Proxy of C++ itkImageToImageFilterIRGBAUC3IUC3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIRGBAUC3IUC3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUC3_GetPointer)

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

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

          itkImageToImageFilterIRGBAUC3IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIRGBAUC3IUC3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUC3_swigregister(itkImageToImageFilterIRGBAUC3IUC3)
class itkImageToImageFilterIRGBAUC3IUL3(itkImageSourcePython.itkImageSourceIUL3):
    r"""Proxy of C++ itkImageToImageFilterIRGBAUC3IUL3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUL3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUL3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUL3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUL3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUL3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUL3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUL3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUL3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUL3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUL3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIRGBAUC3IUL3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUL3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUL3_GetPointer)

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

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

          itkImageToImageFilterIRGBAUC3IUL3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIRGBAUC3IUL3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUL3_swigregister(itkImageToImageFilterIRGBAUC3IUL3)
class itkImageToImageFilterIRGBUC2IF2(itkImageSourcePython.itkImageSourceIF2):
    r"""Proxy of C++ itkImageToImageFilterIRGBUC2IF2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IF2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IF2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IF2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IF2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IF2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IF2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IF2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IF2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IF2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IF2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIRGBUC2IF2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IF2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IF2_GetPointer)

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

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

          itkImageToImageFilterIRGBUC2IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIRGBUC2IF2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IF2_swigregister(itkImageToImageFilterIRGBUC2IF2)
class itkImageToImageFilterIRGBUC2IRGBUC3(itkImageSourcePython.itkImageSourceIRGBUC3):
    r"""Proxy of C++ itkImageToImageFilterIRGBUC2IRGBUC3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IRGBUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IRGBUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IRGBUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IRGBUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IRGBUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IRGBUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IRGBUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IRGBUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IRGBUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IRGBUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIRGBUC2IRGBUC3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IRGBUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IRGBUC3_GetPointer)

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

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

          itkImageToImageFilterIRGBUC2IRGBUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIRGBUC2IRGBUC3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IRGBUC3_swigregister(itkImageToImageFilterIRGBUC2IRGBUC3)
class itkImageToImageFilterIRGBUC2ISS2(itkImageSourcePython.itkImageSourceISS2):
    r"""Proxy of C++ itkImageToImageFilterIRGBUC2ISS2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2ISS2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2ISS2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2ISS2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2ISS2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2ISS2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2ISS2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2ISS2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2ISS2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2ISS2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2ISS2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIRGBUC2ISS2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2ISS2_GetPointer)

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

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

          itkImageToImageFilterIRGBUC2ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIRGBUC2ISS2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2ISS2_swigregister(itkImageToImageFilterIRGBUC2ISS2)
class itkImageToImageFilterIRGBUC2IUC2(itkImageSourcePython.itkImageSourceIUC2):
    r"""Proxy of C++ itkImageToImageFilterIRGBUC2IUC2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIRGBUC2IUC2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUC2_GetPointer)

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

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

          itkImageToImageFilterIRGBUC2IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIRGBUC2IUC2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUC2_swigregister(itkImageToImageFilterIRGBUC2IUC2)
class itkImageToImageFilterIRGBUC2IUL2(itkImageSourcePython.itkImageSourceIUL2):
    r"""Proxy of C++ itkImageToImageFilterIRGBUC2IUL2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUL2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUL2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUL2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUL2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUL2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUL2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUL2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUL2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUL2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUL2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIRGBUC2IUL2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUL2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUL2_GetPointer)

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

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

          itkImageToImageFilterIRGBUC2IUL2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIRGBUC2IUL2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUL2_swigregister(itkImageToImageFilterIRGBUC2IUL2)
class itkImageToImageFilterIRGBUC3IF3(itkImageSourcePython.itkImageSourceIF3):
    r"""Proxy of C++ itkImageToImageFilterIRGBUC3IF3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IF3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IF3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IF3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IF3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IF3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IF3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IF3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IF3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IF3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IF3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIRGBUC3IF3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IF3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IF3_GetPointer)

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

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

          itkImageToImageFilterIRGBUC3IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIRGBUC3IF3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IF3_swigregister(itkImageToImageFilterIRGBUC3IF3)
class itkImageToImageFilterIRGBUC3IRGBUC2(itkImageSourcePython.itkImageSourceIRGBUC2):
    r"""Proxy of C++ itkImageToImageFilterIRGBUC3IRGBUC2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IRGBUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IRGBUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IRGBUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IRGBUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IRGBUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IRGBUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IRGBUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IRGBUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IRGBUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IRGBUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIRGBUC3IRGBUC2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IRGBUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IRGBUC2_GetPointer)

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

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

          itkImageToImageFilterIRGBUC3IRGBUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIRGBUC3IRGBUC2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IRGBUC2_swigregister(itkImageToImageFilterIRGBUC3IRGBUC2)
class itkImageToImageFilterIRGBUC3ISS3(itkImageSourcePython.itkImageSourceISS3):
    r"""Proxy of C++ itkImageToImageFilterIRGBUC3ISS3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3ISS3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3ISS3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3ISS3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3ISS3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3ISS3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3ISS3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3ISS3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3ISS3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3ISS3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3ISS3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIRGBUC3ISS3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3ISS3_GetPointer)

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

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

          itkImageToImageFilterIRGBUC3ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIRGBUC3ISS3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3ISS3_swigregister(itkImageToImageFilterIRGBUC3ISS3)
class itkImageToImageFilterIRGBUC3IUC3(itkImageSourcePython.itkImageSourceIUC3):
    r"""Proxy of C++ itkImageToImageFilterIRGBUC3IUC3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIRGBUC3IUC3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUC3_GetPointer)

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

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

          itkImageToImageFilterIRGBUC3IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIRGBUC3IUC3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUC3_swigregister(itkImageToImageFilterIRGBUC3IUC3)
class itkImageToImageFilterIRGBUC3IUL3(itkImageSourcePython.itkImageSourceIUL3):
    r"""Proxy of C++ itkImageToImageFilterIRGBUC3IUL3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUL3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUL3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUL3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUL3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUL3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUL3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUL3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUL3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUL3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUL3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIRGBUC3IUL3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUL3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUL3_GetPointer)

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

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

          itkImageToImageFilterIRGBUC3IUL3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIRGBUC3IUL3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUL3_swigregister(itkImageToImageFilterIRGBUC3IUL3)
class itkImageToImageFilterISS2ICVF22(itkImageSourcePython.itkImageSourceICVF22):
    r"""Proxy of C++ itkImageToImageFilterISS2ICVF22 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(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF22_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF22_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF22_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF22_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF22_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF22_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF22_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF22_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF22_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF22_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISS2ICVF22
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF22_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF22_GetPointer)

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

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

          itkImageToImageFilterISS2ICVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS2ICVF22 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF22_swigregister(itkImageToImageFilterISS2ICVF22)
class itkImageToImageFilterISS2ICVF32(itkImageSourcePython.itkImageSourceICVF32):
    r"""Proxy of C++ itkImageToImageFilterISS2ICVF32 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(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF32_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF32_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF32_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF32_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF32_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF32_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF32_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF32_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF32_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF32_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISS2ICVF32
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF32_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF32_GetPointer)

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

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

          itkImageToImageFilterISS2ICVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS2ICVF32 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF32_swigregister(itkImageToImageFilterISS2ICVF32)
class itkImageToImageFilterISS2ICVF42(itkImageSourcePython.itkImageSourceICVF42):
    r"""Proxy of C++ itkImageToImageFilterISS2ICVF42 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(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF42_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF42_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF42_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF42_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF42_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF42_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF42_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF42_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF42_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF42_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISS2ICVF42
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF42_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF42_GetPointer)

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

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

          itkImageToImageFilterISS2ICVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS2ICVF42 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF42_swigregister(itkImageToImageFilterISS2ICVF42)
class itkImageToImageFilterISS2IRGBAUC2(itkImageSourcePython.itkImageSourceIRGBAUC2):
    r"""Proxy of C++ itkImageToImageFilterISS2IRGBAUC2 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(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBAUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBAUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBAUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBAUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBAUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBAUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBAUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBAUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBAUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBAUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISS2IRGBAUC2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBAUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBAUC2_GetPointer)

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

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

          itkImageToImageFilterISS2IRGBAUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS2IRGBAUC2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBAUC2_swigregister(itkImageToImageFilterISS2IRGBAUC2)
class itkImageToImageFilterISS2IRGBUC2(itkImageSourcePython.itkImageSourceIRGBUC2):
    r"""Proxy of C++ itkImageToImageFilterISS2IRGBUC2 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(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISS2IRGBUC2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBUC2_GetPointer)

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

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

          itkImageToImageFilterISS2IRGBUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS2IRGBUC2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBUC2_swigregister(itkImageToImageFilterISS2IRGBUC2)
class itkImageToImageFilterISS2ISS3(itkImageSourcePython.itkImageSourceISS3):
    r"""Proxy of C++ itkImageToImageFilterISS2ISS3 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(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ISS3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ISS3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ISS3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ISS3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ISS3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ISS3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ISS3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ISS3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ISS3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ISS3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISS2ISS3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ISS3_GetPointer)

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

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

          itkImageToImageFilterISS2ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS2ISS3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISS2ISS3_swigregister(itkImageToImageFilterISS2ISS3)
class itkImageToImageFilterISS2ISSRTD22(itkImageSourcePython.itkImageSourceISSRTD22):
    r"""Proxy of C++ itkImageToImageFilterISS2ISSRTD22 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(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ISSRTD22_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ISSRTD22_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ISSRTD22_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ISSRTD22_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ISSRTD22_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ISSRTD22_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ISSRTD22_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ISSRTD22_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ISSRTD22_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ISSRTD22_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISS2ISSRTD22
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ISSRTD22_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2ISSRTD22_GetPointer)

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

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

          itkImageToImageFilterISS2ISSRTD22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS2ISSRTD22 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISS2ISSRTD22_swigregister(itkImageToImageFilterISS2ISSRTD22)
class itkImageToImageFilterISS2IVF22(itkImageSourcePython.itkImageSourceIVF22):
    r"""Proxy of C++ itkImageToImageFilterISS2IVF22 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(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF22_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF22_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF22_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF22_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF22_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF22_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF22_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF22_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF22_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF22_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISS2IVF22
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF22_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF22_GetPointer)

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

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

          itkImageToImageFilterISS2IVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS2IVF22 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF22_swigregister(itkImageToImageFilterISS2IVF22)
class itkImageToImageFilterISS2IVF32(itkImageSourcePython.itkImageSourceIVF32):
    r"""Proxy of C++ itkImageToImageFilterISS2IVF32 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(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF32_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF32_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF32_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF32_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF32_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF32_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF32_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF32_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF32_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF32_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISS2IVF32
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF32_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF32_GetPointer)

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

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

          itkImageToImageFilterISS2IVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS2IVF32 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF32_swigregister(itkImageToImageFilterISS2IVF32)
class itkImageToImageFilterISS2IVF42(itkImageSourcePython.itkImageSourceIVF42):
    r"""Proxy of C++ itkImageToImageFilterISS2IVF42 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(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF42_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF42_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF42_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF42_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF42_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF42_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF42_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF42_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF42_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF42_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISS2IVF42
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF42_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF42_GetPointer)

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

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

          itkImageToImageFilterISS2IVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS2IVF42 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF42_swigregister(itkImageToImageFilterISS2IVF42)
class itkImageToImageFilterISS2VIF2(itkImageSourcePython.itkImageSourceVIF2):
    r"""Proxy of C++ itkImageToImageFilterISS2VIF2 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(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VIF2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VIF2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VIF2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VIF2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VIF2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VIF2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VIF2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VIF2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VIF2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VIF2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISS2VIF2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VIF2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VIF2_GetPointer)

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

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

          itkImageToImageFilterISS2VIF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS2VIF2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISS2VIF2_swigregister(itkImageToImageFilterISS2VIF2)
class itkImageToImageFilterISS2VISS2(itkImageSourcePython.itkImageSourceVISS2):
    r"""Proxy of C++ itkImageToImageFilterISS2VISS2 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(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VISS2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VISS2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VISS2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VISS2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VISS2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VISS2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VISS2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VISS2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VISS2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VISS2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISS2VISS2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VISS2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VISS2_GetPointer)

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

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

          itkImageToImageFilterISS2VISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS2VISS2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISS2VISS2_swigregister(itkImageToImageFilterISS2VISS2)
class itkImageToImageFilterISS2VIUC2(itkImageSourcePython.itkImageSourceVIUC2):
    r"""Proxy of C++ itkImageToImageFilterISS2VIUC2 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(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VIUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VIUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VIUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VIUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VIUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VIUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VIUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VIUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VIUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VIUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISS2VIUC2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VIUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS2VIUC2_GetPointer)

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

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

          itkImageToImageFilterISS2VIUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS2VIUC2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISS2VIUC2_swigregister(itkImageToImageFilterISS2VIUC2)
class itkImageToImageFilterISS3ICVF23(itkImageSourcePython.itkImageSourceICVF23):
    r"""Proxy of C++ itkImageToImageFilterISS3ICVF23 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(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF23_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF23_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF23_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF23_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF23_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF23_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF23_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF23_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF23_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF23_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISS3ICVF23
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF23_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF23_GetPointer)

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

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

          itkImageToImageFilterISS3ICVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS3ICVF23 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF23_swigregister(itkImageToImageFilterISS3ICVF23)
class itkImageToImageFilterISS3ICVF33(itkImageSourcePython.itkImageSourceICVF33):
    r"""Proxy of C++ itkImageToImageFilterISS3ICVF33 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(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF33_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF33_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF33_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF33_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF33_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF33_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF33_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF33_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF33_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF33_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISS3ICVF33
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF33_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF33_GetPointer)

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

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

          itkImageToImageFilterISS3ICVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS3ICVF33 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF33_swigregister(itkImageToImageFilterISS3ICVF33)
class itkImageToImageFilterISS3ICVF43(itkImageSourcePython.itkImageSourceICVF43):
    r"""Proxy of C++ itkImageToImageFilterISS3ICVF43 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(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF43_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF43_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF43_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF43_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF43_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF43_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF43_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF43_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF43_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF43_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISS3ICVF43
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF43_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF43_GetPointer)

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

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

          itkImageToImageFilterISS3ICVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS3ICVF43 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF43_swigregister(itkImageToImageFilterISS3ICVF43)
class itkImageToImageFilterISS3IRGBAUC3(itkImageSourcePython.itkImageSourceIRGBAUC3):
    r"""Proxy of C++ itkImageToImageFilterISS3IRGBAUC3 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(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBAUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBAUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBAUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBAUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBAUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBAUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBAUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBAUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBAUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBAUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISS3IRGBAUC3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBAUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBAUC3_GetPointer)

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

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

          itkImageToImageFilterISS3IRGBAUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS3IRGBAUC3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBAUC3_swigregister(itkImageToImageFilterISS3IRGBAUC3)
class itkImageToImageFilterISS3IRGBUC3(itkImageSourcePython.itkImageSourceIRGBUC3):
    r"""Proxy of C++ itkImageToImageFilterISS3IRGBUC3 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(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISS3IRGBUC3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBUC3_GetPointer)

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

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

          itkImageToImageFilterISS3IRGBUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS3IRGBUC3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBUC3_swigregister(itkImageToImageFilterISS3IRGBUC3)
class itkImageToImageFilterISS3ISS2(itkImageSourcePython.itkImageSourceISS2):
    r"""Proxy of C++ itkImageToImageFilterISS3ISS2 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(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ISS2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ISS2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ISS2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ISS2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ISS2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ISS2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ISS2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ISS2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ISS2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ISS2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISS3ISS2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ISS2_GetPointer)

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

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

          itkImageToImageFilterISS3ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS3ISS2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISS3ISS2_swigregister(itkImageToImageFilterISS3ISS2)
class itkImageToImageFilterISS3ISSRTD33(itkImageSourcePython.itkImageSourceISSRTD33):
    r"""Proxy of C++ itkImageToImageFilterISS3ISSRTD33 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(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ISSRTD33_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ISSRTD33_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ISSRTD33_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ISSRTD33_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ISSRTD33_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ISSRTD33_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ISSRTD33_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ISSRTD33_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ISSRTD33_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ISSRTD33_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISS3ISSRTD33
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ISSRTD33_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3ISSRTD33_GetPointer)

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

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

          itkImageToImageFilterISS3ISSRTD33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS3ISSRTD33 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISS3ISSRTD33_swigregister(itkImageToImageFilterISS3ISSRTD33)
class itkImageToImageFilterISS3IVF23(itkImageSourcePython.itkImageSourceIVF23):
    r"""Proxy of C++ itkImageToImageFilterISS3IVF23 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(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF23_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF23_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF23_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF23_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF23_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF23_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF23_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF23_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF23_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF23_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISS3IVF23
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF23_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF23_GetPointer)

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

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

          itkImageToImageFilterISS3IVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS3IVF23 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF23_swigregister(itkImageToImageFilterISS3IVF23)
class itkImageToImageFilterISS3IVF33(itkImageSourcePython.itkImageSourceIVF33):
    r"""Proxy of C++ itkImageToImageFilterISS3IVF33 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(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF33_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF33_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF33_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF33_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF33_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF33_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF33_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF33_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF33_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF33_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISS3IVF33
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF33_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF33_GetPointer)

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

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

          itkImageToImageFilterISS3IVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS3IVF33 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF33_swigregister(itkImageToImageFilterISS3IVF33)
class itkImageToImageFilterISS3IVF43(itkImageSourcePython.itkImageSourceIVF43):
    r"""Proxy of C++ itkImageToImageFilterISS3IVF43 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(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF43_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF43_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF43_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF43_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF43_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF43_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF43_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF43_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF43_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF43_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISS3IVF43
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF43_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF43_GetPointer)

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

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

          itkImageToImageFilterISS3IVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS3IVF43 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF43_swigregister(itkImageToImageFilterISS3IVF43)
class itkImageToImageFilterISS3VIF3(itkImageSourcePython.itkImageSourceVIF3):
    r"""Proxy of C++ itkImageToImageFilterISS3VIF3 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(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VIF3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VIF3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VIF3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VIF3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VIF3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VIF3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VIF3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VIF3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VIF3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VIF3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISS3VIF3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VIF3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VIF3_GetPointer)

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

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

          itkImageToImageFilterISS3VIF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS3VIF3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISS3VIF3_swigregister(itkImageToImageFilterISS3VIF3)
class itkImageToImageFilterISS3VISS3(itkImageSourcePython.itkImageSourceVISS3):
    r"""Proxy of C++ itkImageToImageFilterISS3VISS3 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(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VISS3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VISS3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VISS3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VISS3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VISS3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VISS3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VISS3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VISS3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VISS3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VISS3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISS3VISS3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VISS3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VISS3_GetPointer)

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

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

          itkImageToImageFilterISS3VISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS3VISS3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISS3VISS3_swigregister(itkImageToImageFilterISS3VISS3)
class itkImageToImageFilterISS3VIUC3(itkImageSourcePython.itkImageSourceVIUC3):
    r"""Proxy of C++ itkImageToImageFilterISS3VIUC3 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(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VIUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VIUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VIUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VIUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VIUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VIUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VIUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VIUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VIUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VIUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISS3VIUC3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VIUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISS3VIUC3_GetPointer)

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

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

          itkImageToImageFilterISS3VIUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISS3VIUC3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISS3VIUC3_swigregister(itkImageToImageFilterISS3VIUC3)
class itkImageToImageFilterISSRTD22IF2(itkImageSourcePython.itkImageSourceIF2):
    r"""Proxy of C++ itkImageToImageFilterISSRTD22IF2 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(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22IF2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22IF2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22IF2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22IF2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22IF2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22IF2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22IF2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22IF2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22IF2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22IF2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISSRTD22IF2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22IF2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22IF2_GetPointer)

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

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

          itkImageToImageFilterISSRTD22IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISSRTD22IF2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22IF2_swigregister(itkImageToImageFilterISSRTD22IF2)
class itkImageToImageFilterISSRTD22ISS2(itkImageSourcePython.itkImageSourceISS2):
    r"""Proxy of C++ itkImageToImageFilterISSRTD22ISS2 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(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22ISS2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22ISS2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22ISS2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22ISS2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22ISS2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22ISS2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22ISS2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22ISS2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22ISS2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22ISS2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISSRTD22ISS2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22ISS2_GetPointer)

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

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

          itkImageToImageFilterISSRTD22ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISSRTD22ISS2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22ISS2_swigregister(itkImageToImageFilterISSRTD22ISS2)
class itkImageToImageFilterISSRTD22IUC2(itkImageSourcePython.itkImageSourceIUC2):
    r"""Proxy of C++ itkImageToImageFilterISSRTD22IUC2 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(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22IUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22IUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22IUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22IUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22IUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22IUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22IUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22IUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22IUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22IUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISSRTD22IUC2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22IUC2_GetPointer)

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

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

          itkImageToImageFilterISSRTD22IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISSRTD22IUC2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD22IUC2_swigregister(itkImageToImageFilterISSRTD22IUC2)
class itkImageToImageFilterISSRTD33IF3(itkImageSourcePython.itkImageSourceIF3):
    r"""Proxy of C++ itkImageToImageFilterISSRTD33IF3 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(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33IF3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33IF3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33IF3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33IF3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33IF3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33IF3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33IF3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33IF3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33IF3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33IF3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISSRTD33IF3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33IF3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33IF3_GetPointer)

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

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

          itkImageToImageFilterISSRTD33IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISSRTD33IF3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33IF3_swigregister(itkImageToImageFilterISSRTD33IF3)
class itkImageToImageFilterISSRTD33ISS3(itkImageSourcePython.itkImageSourceISS3):
    r"""Proxy of C++ itkImageToImageFilterISSRTD33ISS3 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(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33ISS3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33ISS3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33ISS3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33ISS3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33ISS3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33ISS3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33ISS3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33ISS3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33ISS3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33ISS3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISSRTD33ISS3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33ISS3_GetPointer)

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

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

          itkImageToImageFilterISSRTD33ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISSRTD33ISS3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33ISS3_swigregister(itkImageToImageFilterISSRTD33ISS3)
class itkImageToImageFilterISSRTD33IUC3(itkImageSourcePython.itkImageSourceIUC3):
    r"""Proxy of C++ itkImageToImageFilterISSRTD33IUC3 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(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33IUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33IUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33IUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33IUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33IUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33IUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33IUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33IUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33IUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33IUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterISSRTD33IUC3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33IUC3_GetPointer)

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

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

          itkImageToImageFilterISSRTD33IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterISSRTD33IUC3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterISSRTD33IUC3_swigregister(itkImageToImageFilterISSRTD33IUC3)
class itkImageToImageFilterIUC2ICVF22(itkImageSourcePython.itkImageSourceICVF22):
    r"""Proxy of C++ itkImageToImageFilterIUC2ICVF22 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF22_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF22_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF22_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF22_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF22_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF22_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF22_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF22_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF22_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF22_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUC2ICVF22
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF22_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF22_GetPointer)

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

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

          itkImageToImageFilterIUC2ICVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC2ICVF22 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF22_swigregister(itkImageToImageFilterIUC2ICVF22)
class itkImageToImageFilterIUC2ICVF32(itkImageSourcePython.itkImageSourceICVF32):
    r"""Proxy of C++ itkImageToImageFilterIUC2ICVF32 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF32_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF32_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF32_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF32_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF32_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF32_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF32_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF32_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF32_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF32_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUC2ICVF32
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF32_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF32_GetPointer)

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

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

          itkImageToImageFilterIUC2ICVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC2ICVF32 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF32_swigregister(itkImageToImageFilterIUC2ICVF32)
class itkImageToImageFilterIUC2ICVF42(itkImageSourcePython.itkImageSourceICVF42):
    r"""Proxy of C++ itkImageToImageFilterIUC2ICVF42 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF42_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF42_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF42_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF42_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF42_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF42_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF42_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF42_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF42_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF42_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUC2ICVF42
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF42_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF42_GetPointer)

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

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

          itkImageToImageFilterIUC2ICVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC2ICVF42 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF42_swigregister(itkImageToImageFilterIUC2ICVF42)
class itkImageToImageFilterIUC2IRGBAUC2(itkImageSourcePython.itkImageSourceIRGBAUC2):
    r"""Proxy of C++ itkImageToImageFilterIUC2IRGBAUC2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBAUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBAUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBAUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBAUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBAUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBAUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBAUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBAUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBAUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBAUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUC2IRGBAUC2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBAUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBAUC2_GetPointer)

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

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

          itkImageToImageFilterIUC2IRGBAUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC2IRGBAUC2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBAUC2_swigregister(itkImageToImageFilterIUC2IRGBAUC2)
class itkImageToImageFilterIUC2IRGBUC2(itkImageSourcePython.itkImageSourceIRGBUC2):
    r"""Proxy of C++ itkImageToImageFilterIUC2IRGBUC2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUC2IRGBUC2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBUC2_GetPointer)

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

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

          itkImageToImageFilterIUC2IRGBUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC2IRGBUC2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBUC2_swigregister(itkImageToImageFilterIUC2IRGBUC2)
class itkImageToImageFilterIUC2ISSRTD22(itkImageSourcePython.itkImageSourceISSRTD22):
    r"""Proxy of C++ itkImageToImageFilterIUC2ISSRTD22 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ISSRTD22_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ISSRTD22_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ISSRTD22_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ISSRTD22_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ISSRTD22_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ISSRTD22_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ISSRTD22_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ISSRTD22_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ISSRTD22_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ISSRTD22_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUC2ISSRTD22
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ISSRTD22_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ISSRTD22_GetPointer)

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

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

          itkImageToImageFilterIUC2ISSRTD22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC2ISSRTD22 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUC2ISSRTD22_swigregister(itkImageToImageFilterIUC2ISSRTD22)
class itkImageToImageFilterIUC2IUC3(itkImageSourcePython.itkImageSourceIUC3):
    r"""Proxy of C++ itkImageToImageFilterIUC2IUC3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUC2IUC3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IUC3_GetPointer)

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

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

          itkImageToImageFilterIUC2IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC2IUC3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IUC3_swigregister(itkImageToImageFilterIUC2IUC3)
class itkImageToImageFilterIUC2IVF22(itkImageSourcePython.itkImageSourceIVF22):
    r"""Proxy of C++ itkImageToImageFilterIUC2IVF22 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF22_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF22_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF22_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF22_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF22_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF22_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF22_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF22_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF22_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF22_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUC2IVF22
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF22_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF22_GetPointer)

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

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

          itkImageToImageFilterIUC2IVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC2IVF22 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF22_swigregister(itkImageToImageFilterIUC2IVF22)
class itkImageToImageFilterIUC2IVF32(itkImageSourcePython.itkImageSourceIVF32):
    r"""Proxy of C++ itkImageToImageFilterIUC2IVF32 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF32_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF32_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF32_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF32_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF32_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF32_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF32_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF32_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF32_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF32_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUC2IVF32
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF32_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF32_GetPointer)

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

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

          itkImageToImageFilterIUC2IVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC2IVF32 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF32_swigregister(itkImageToImageFilterIUC2IVF32)
class itkImageToImageFilterIUC2IVF42(itkImageSourcePython.itkImageSourceIVF42):
    r"""Proxy of C++ itkImageToImageFilterIUC2IVF42 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF42_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF42_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF42_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF42_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF42_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF42_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF42_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF42_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF42_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF42_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUC2IVF42
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF42_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF42_GetPointer)

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

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

          itkImageToImageFilterIUC2IVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC2IVF42 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF42_swigregister(itkImageToImageFilterIUC2IVF42)
class itkImageToImageFilterIUC2VIF2(itkImageSourcePython.itkImageSourceVIF2):
    r"""Proxy of C++ itkImageToImageFilterIUC2VIF2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIF2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIF2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIF2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIF2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIF2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIF2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIF2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIF2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIF2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIF2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUC2VIF2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIF2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIF2_GetPointer)

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

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

          itkImageToImageFilterIUC2VIF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC2VIF2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIF2_swigregister(itkImageToImageFilterIUC2VIF2)
class itkImageToImageFilterIUC2VISS2(itkImageSourcePython.itkImageSourceVISS2):
    r"""Proxy of C++ itkImageToImageFilterIUC2VISS2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VISS2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VISS2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VISS2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VISS2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VISS2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VISS2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VISS2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VISS2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VISS2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VISS2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUC2VISS2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VISS2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VISS2_GetPointer)

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

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

          itkImageToImageFilterIUC2VISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC2VISS2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VISS2_swigregister(itkImageToImageFilterIUC2VISS2)
class itkImageToImageFilterIUC2VIUC2(itkImageSourcePython.itkImageSourceVIUC2):
    r"""Proxy of C++ itkImageToImageFilterIUC2VIUC2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUC2VIUC2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIUC2_GetPointer)

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

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

          itkImageToImageFilterIUC2VIUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC2VIUC2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIUC2_swigregister(itkImageToImageFilterIUC2VIUC2)
class itkImageToImageFilterIUC3ICVF23(itkImageSourcePython.itkImageSourceICVF23):
    r"""Proxy of C++ itkImageToImageFilterIUC3ICVF23 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF23_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF23_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF23_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF23_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF23_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF23_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF23_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF23_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF23_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF23_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUC3ICVF23
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF23_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF23_GetPointer)

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

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

          itkImageToImageFilterIUC3ICVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC3ICVF23 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF23_swigregister(itkImageToImageFilterIUC3ICVF23)
class itkImageToImageFilterIUC3ICVF33(itkImageSourcePython.itkImageSourceICVF33):
    r"""Proxy of C++ itkImageToImageFilterIUC3ICVF33 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF33_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF33_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF33_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF33_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF33_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF33_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF33_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF33_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF33_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF33_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUC3ICVF33
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF33_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF33_GetPointer)

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

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

          itkImageToImageFilterIUC3ICVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC3ICVF33 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF33_swigregister(itkImageToImageFilterIUC3ICVF33)
class itkImageToImageFilterIUC3ICVF43(itkImageSourcePython.itkImageSourceICVF43):
    r"""Proxy of C++ itkImageToImageFilterIUC3ICVF43 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF43_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF43_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF43_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF43_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF43_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF43_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF43_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF43_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF43_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF43_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUC3ICVF43
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF43_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF43_GetPointer)

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

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

          itkImageToImageFilterIUC3ICVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC3ICVF43 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF43_swigregister(itkImageToImageFilterIUC3ICVF43)
class itkImageToImageFilterIUC3IRGBAUC3(itkImageSourcePython.itkImageSourceIRGBAUC3):
    r"""Proxy of C++ itkImageToImageFilterIUC3IRGBAUC3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBAUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBAUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBAUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBAUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBAUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBAUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBAUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBAUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBAUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBAUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUC3IRGBAUC3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBAUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBAUC3_GetPointer)

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

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

          itkImageToImageFilterIUC3IRGBAUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC3IRGBAUC3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBAUC3_swigregister(itkImageToImageFilterIUC3IRGBAUC3)
class itkImageToImageFilterIUC3IRGBUC3(itkImageSourcePython.itkImageSourceIRGBUC3):
    r"""Proxy of C++ itkImageToImageFilterIUC3IRGBUC3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUC3IRGBUC3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBUC3_GetPointer)

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

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

          itkImageToImageFilterIUC3IRGBUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC3IRGBUC3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBUC3_swigregister(itkImageToImageFilterIUC3IRGBUC3)
class itkImageToImageFilterIUC3ISSRTD33(itkImageSourcePython.itkImageSourceISSRTD33):
    r"""Proxy of C++ itkImageToImageFilterIUC3ISSRTD33 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ISSRTD33_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ISSRTD33_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ISSRTD33_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ISSRTD33_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ISSRTD33_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ISSRTD33_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ISSRTD33_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ISSRTD33_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ISSRTD33_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ISSRTD33_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUC3ISSRTD33
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ISSRTD33_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ISSRTD33_GetPointer)

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

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

          itkImageToImageFilterIUC3ISSRTD33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC3ISSRTD33 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUC3ISSRTD33_swigregister(itkImageToImageFilterIUC3ISSRTD33)
class itkImageToImageFilterIUC3IUC2(itkImageSourcePython.itkImageSourceIUC2):
    r"""Proxy of C++ itkImageToImageFilterIUC3IUC2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUC3IUC2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IUC2_GetPointer)

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

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

          itkImageToImageFilterIUC3IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC3IUC2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IUC2_swigregister(itkImageToImageFilterIUC3IUC2)
class itkImageToImageFilterIUC3IVF23(itkImageSourcePython.itkImageSourceIVF23):
    r"""Proxy of C++ itkImageToImageFilterIUC3IVF23 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF23_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF23_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF23_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF23_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF23_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF23_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF23_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF23_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF23_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF23_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUC3IVF23
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF23_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF23_GetPointer)

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

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

          itkImageToImageFilterIUC3IVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC3IVF23 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF23_swigregister(itkImageToImageFilterIUC3IVF23)
class itkImageToImageFilterIUC3IVF33(itkImageSourcePython.itkImageSourceIVF33):
    r"""Proxy of C++ itkImageToImageFilterIUC3IVF33 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF33_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF33_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF33_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF33_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF33_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF33_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF33_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF33_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF33_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF33_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUC3IVF33
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF33_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF33_GetPointer)

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

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

          itkImageToImageFilterIUC3IVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC3IVF33 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF33_swigregister(itkImageToImageFilterIUC3IVF33)
class itkImageToImageFilterIUC3IVF43(itkImageSourcePython.itkImageSourceIVF43):
    r"""Proxy of C++ itkImageToImageFilterIUC3IVF43 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF43_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF43_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF43_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF43_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF43_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF43_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF43_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF43_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF43_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF43_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUC3IVF43
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF43_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF43_GetPointer)

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

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

          itkImageToImageFilterIUC3IVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC3IVF43 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF43_swigregister(itkImageToImageFilterIUC3IVF43)
class itkImageToImageFilterIUC3VIF3(itkImageSourcePython.itkImageSourceVIF3):
    r"""Proxy of C++ itkImageToImageFilterIUC3VIF3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIF3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIF3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIF3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIF3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIF3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIF3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIF3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIF3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIF3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIF3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUC3VIF3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIF3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIF3_GetPointer)

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

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

          itkImageToImageFilterIUC3VIF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC3VIF3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIF3_swigregister(itkImageToImageFilterIUC3VIF3)
class itkImageToImageFilterIUC3VISS3(itkImageSourcePython.itkImageSourceVISS3):
    r"""Proxy of C++ itkImageToImageFilterIUC3VISS3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VISS3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VISS3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VISS3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VISS3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VISS3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VISS3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VISS3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VISS3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VISS3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VISS3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUC3VISS3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VISS3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VISS3_GetPointer)

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

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

          itkImageToImageFilterIUC3VISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC3VISS3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VISS3_swigregister(itkImageToImageFilterIUC3VISS3)
class itkImageToImageFilterIUC3VIUC3(itkImageSourcePython.itkImageSourceVIUC3):
    r"""Proxy of C++ itkImageToImageFilterIUC3VIUC3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUC3VIUC3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIUC3_GetPointer)

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

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

          itkImageToImageFilterIUC3VIUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUC3VIUC3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIUC3_swigregister(itkImageToImageFilterIUC3VIUC3)
class itkImageToImageFilterIUL2IRGBAUC2(itkImageSourcePython.itkImageSourceIRGBAUC2):
    r"""Proxy of C++ itkImageToImageFilterIUL2IRGBAUC2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBAUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBAUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBAUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBAUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBAUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBAUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBAUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBAUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBAUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBAUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUL2IRGBAUC2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBAUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBAUC2_GetPointer)

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

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

          itkImageToImageFilterIUL2IRGBAUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUL2IRGBAUC2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBAUC2_swigregister(itkImageToImageFilterIUL2IRGBAUC2)
class itkImageToImageFilterIUL2IRGBUC2(itkImageSourcePython.itkImageSourceIRGBUC2):
    r"""Proxy of C++ itkImageToImageFilterIUL2IRGBUC2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUL2IRGBUC2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBUC2_GetPointer)

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

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

          itkImageToImageFilterIUL2IRGBUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUL2IRGBUC2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBUC2_swigregister(itkImageToImageFilterIUL2IRGBUC2)
class itkImageToImageFilterIUL3IRGBAUC3(itkImageSourcePython.itkImageSourceIRGBAUC3):
    r"""Proxy of C++ itkImageToImageFilterIUL3IRGBAUC3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBAUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBAUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBAUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBAUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBAUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBAUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBAUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBAUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBAUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBAUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUL3IRGBAUC3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBAUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBAUC3_GetPointer)

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

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

          itkImageToImageFilterIUL3IRGBAUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUL3IRGBAUC3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBAUC3_swigregister(itkImageToImageFilterIUL3IRGBAUC3)
class itkImageToImageFilterIUL3IRGBUC3(itkImageSourcePython.itkImageSourceIRGBUC3):
    r"""Proxy of C++ itkImageToImageFilterIUL3IRGBUC3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIUL3IRGBUC3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBUC3_GetPointer)

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

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

          itkImageToImageFilterIUL3IRGBUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIUL3IRGBUC3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBUC3_swigregister(itkImageToImageFilterIUL3IRGBUC3)
class itkImageToImageFilterIVF22IF2(itkImageSourcePython.itkImageSourceIF2):
    r"""Proxy of C++ itkImageToImageFilterIVF22IF2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22IF2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22IF2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22IF2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22IF2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22IF2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22IF2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22IF2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22IF2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22IF2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22IF2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIVF22IF2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22IF2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22IF2_GetPointer)

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

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

          itkImageToImageFilterIVF22IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF22IF2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIVF22IF2_swigregister(itkImageToImageFilterIVF22IF2)
class itkImageToImageFilterIVF22ISS2(itkImageSourcePython.itkImageSourceISS2):
    r"""Proxy of C++ itkImageToImageFilterIVF22ISS2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22ISS2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22ISS2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22ISS2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22ISS2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22ISS2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22ISS2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22ISS2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22ISS2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22ISS2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22ISS2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIVF22ISS2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22ISS2_GetPointer)

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

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

          itkImageToImageFilterIVF22ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF22ISS2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIVF22ISS2_swigregister(itkImageToImageFilterIVF22ISS2)
class itkImageToImageFilterIVF22IUC2(itkImageSourcePython.itkImageSourceIUC2):
    r"""Proxy of C++ itkImageToImageFilterIVF22IUC2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22IUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22IUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22IUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22IUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22IUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22IUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22IUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22IUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22IUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22IUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIVF22IUC2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF22IUC2_GetPointer)

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

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

          itkImageToImageFilterIVF22IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF22IUC2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIVF22IUC2_swigregister(itkImageToImageFilterIVF22IUC2)
class itkImageToImageFilterIVF23IF3(itkImageSourcePython.itkImageSourceIF3):
    r"""Proxy of C++ itkImageToImageFilterIVF23IF3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23IF3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23IF3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23IF3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23IF3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23IF3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23IF3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23IF3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23IF3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23IF3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23IF3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIVF23IF3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23IF3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23IF3_GetPointer)

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

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

          itkImageToImageFilterIVF23IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF23IF3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIVF23IF3_swigregister(itkImageToImageFilterIVF23IF3)
class itkImageToImageFilterIVF23ISS3(itkImageSourcePython.itkImageSourceISS3):
    r"""Proxy of C++ itkImageToImageFilterIVF23ISS3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23ISS3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23ISS3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23ISS3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23ISS3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23ISS3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23ISS3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23ISS3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23ISS3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23ISS3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23ISS3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIVF23ISS3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23ISS3_GetPointer)

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

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

          itkImageToImageFilterIVF23ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF23ISS3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIVF23ISS3_swigregister(itkImageToImageFilterIVF23ISS3)
class itkImageToImageFilterIVF23IUC3(itkImageSourcePython.itkImageSourceIUC3):
    r"""Proxy of C++ itkImageToImageFilterIVF23IUC3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23IUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23IUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23IUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23IUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23IUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23IUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23IUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23IUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23IUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23IUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIVF23IUC3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF23IUC3_GetPointer)

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

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

          itkImageToImageFilterIVF23IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF23IUC3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIVF23IUC3_swigregister(itkImageToImageFilterIVF23IUC3)
class itkImageToImageFilterIVF32IF2(itkImageSourcePython.itkImageSourceIF2):
    r"""Proxy of C++ itkImageToImageFilterIVF32IF2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32IF2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32IF2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32IF2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32IF2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32IF2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32IF2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32IF2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32IF2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32IF2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32IF2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIVF32IF2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32IF2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32IF2_GetPointer)

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

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

          itkImageToImageFilterIVF32IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF32IF2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIVF32IF2_swigregister(itkImageToImageFilterIVF32IF2)
class itkImageToImageFilterIVF32ISS2(itkImageSourcePython.itkImageSourceISS2):
    r"""Proxy of C++ itkImageToImageFilterIVF32ISS2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32ISS2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32ISS2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32ISS2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32ISS2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32ISS2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32ISS2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32ISS2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32ISS2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32ISS2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32ISS2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIVF32ISS2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32ISS2_GetPointer)

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

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

          itkImageToImageFilterIVF32ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF32ISS2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIVF32ISS2_swigregister(itkImageToImageFilterIVF32ISS2)
class itkImageToImageFilterIVF32IUC2(itkImageSourcePython.itkImageSourceIUC2):
    r"""Proxy of C++ itkImageToImageFilterIVF32IUC2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32IUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32IUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32IUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32IUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32IUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32IUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32IUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32IUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32IUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32IUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIVF32IUC2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF32IUC2_GetPointer)

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

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

          itkImageToImageFilterIVF32IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF32IUC2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIVF32IUC2_swigregister(itkImageToImageFilterIVF32IUC2)
class itkImageToImageFilterIVF33IF3(itkImageSourcePython.itkImageSourceIF3):
    r"""Proxy of C++ itkImageToImageFilterIVF33IF3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33IF3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33IF3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33IF3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33IF3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33IF3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33IF3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33IF3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33IF3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33IF3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33IF3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIVF33IF3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33IF3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33IF3_GetPointer)

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

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

          itkImageToImageFilterIVF33IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF33IF3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIVF33IF3_swigregister(itkImageToImageFilterIVF33IF3)
class itkImageToImageFilterIVF33ISS3(itkImageSourcePython.itkImageSourceISS3):
    r"""Proxy of C++ itkImageToImageFilterIVF33ISS3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33ISS3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33ISS3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33ISS3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33ISS3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33ISS3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33ISS3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33ISS3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33ISS3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33ISS3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33ISS3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIVF33ISS3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33ISS3_GetPointer)

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

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

          itkImageToImageFilterIVF33ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF33ISS3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIVF33ISS3_swigregister(itkImageToImageFilterIVF33ISS3)
class itkImageToImageFilterIVF33IUC3(itkImageSourcePython.itkImageSourceIUC3):
    r"""Proxy of C++ itkImageToImageFilterIVF33IUC3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33IUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33IUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33IUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33IUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33IUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33IUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33IUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33IUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33IUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33IUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIVF33IUC3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF33IUC3_GetPointer)

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

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

          itkImageToImageFilterIVF33IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF33IUC3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIVF33IUC3_swigregister(itkImageToImageFilterIVF33IUC3)
class itkImageToImageFilterIVF42IF2(itkImageSourcePython.itkImageSourceIF2):
    r"""Proxy of C++ itkImageToImageFilterIVF42IF2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42IF2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42IF2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42IF2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42IF2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42IF2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42IF2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42IF2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42IF2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42IF2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42IF2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIVF42IF2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42IF2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42IF2_GetPointer)

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

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

          itkImageToImageFilterIVF42IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF42IF2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIVF42IF2_swigregister(itkImageToImageFilterIVF42IF2)
class itkImageToImageFilterIVF42ISS2(itkImageSourcePython.itkImageSourceISS2):
    r"""Proxy of C++ itkImageToImageFilterIVF42ISS2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42ISS2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42ISS2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42ISS2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42ISS2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42ISS2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42ISS2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42ISS2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42ISS2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42ISS2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42ISS2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIVF42ISS2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42ISS2_GetPointer)

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

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

          itkImageToImageFilterIVF42ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF42ISS2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIVF42ISS2_swigregister(itkImageToImageFilterIVF42ISS2)
class itkImageToImageFilterIVF42IUC2(itkImageSourcePython.itkImageSourceIUC2):
    r"""Proxy of C++ itkImageToImageFilterIVF42IUC2 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(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42IUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42IUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42IUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42IUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42IUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42IUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42IUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42IUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42IUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42IUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIVF42IUC2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF42IUC2_GetPointer)

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

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

          itkImageToImageFilterIVF42IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF42IUC2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIVF42IUC2_swigregister(itkImageToImageFilterIVF42IUC2)
class itkImageToImageFilterIVF43IF3(itkImageSourcePython.itkImageSourceIF3):
    r"""Proxy of C++ itkImageToImageFilterIVF43IF3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43IF3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43IF3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43IF3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43IF3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43IF3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43IF3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43IF3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43IF3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43IF3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43IF3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIVF43IF3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43IF3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43IF3_GetPointer)

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

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

          itkImageToImageFilterIVF43IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF43IF3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIVF43IF3_swigregister(itkImageToImageFilterIVF43IF3)
class itkImageToImageFilterIVF43ISS3(itkImageSourcePython.itkImageSourceISS3):
    r"""Proxy of C++ itkImageToImageFilterIVF43ISS3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43ISS3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43ISS3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43ISS3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43ISS3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43ISS3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43ISS3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43ISS3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43ISS3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43ISS3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43ISS3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIVF43ISS3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43ISS3_GetPointer)

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

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

          itkImageToImageFilterIVF43ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF43ISS3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIVF43ISS3_swigregister(itkImageToImageFilterIVF43ISS3)
class itkImageToImageFilterIVF43IUC3(itkImageSourcePython.itkImageSourceIUC3):
    r"""Proxy of C++ itkImageToImageFilterIVF43IUC3 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(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43IUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43IUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43IUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43IUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43IUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43IUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43IUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43IUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43IUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43IUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterIVF43IUC3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterIVF43IUC3_GetPointer)

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

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

          itkImageToImageFilterIVF43IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterIVF43IUC3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterIVF43IUC3_swigregister(itkImageToImageFilterIVF43IUC3)
class itkImageToImageFilterVIF2IF2(itkImageSourcePython.itkImageSourceIF2):
    r"""Proxy of C++ itkImageToImageFilterVIF2IF2 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(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2IF2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2IF2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2IF2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2IF2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2IF2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2IF2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2IF2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2IF2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2IF2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2IF2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterVIF2IF2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2IF2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2IF2_GetPointer)

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

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

          itkImageToImageFilterVIF2IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterVIF2IF2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterVIF2IF2_swigregister(itkImageToImageFilterVIF2IF2)
class itkImageToImageFilterVIF2ISS2(itkImageSourcePython.itkImageSourceISS2):
    r"""Proxy of C++ itkImageToImageFilterVIF2ISS2 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(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2ISS2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2ISS2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2ISS2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2ISS2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2ISS2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2ISS2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2ISS2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2ISS2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2ISS2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2ISS2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterVIF2ISS2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2ISS2_GetPointer)

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

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

          itkImageToImageFilterVIF2ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterVIF2ISS2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterVIF2ISS2_swigregister(itkImageToImageFilterVIF2ISS2)
class itkImageToImageFilterVIF2IUC2(itkImageSourcePython.itkImageSourceIUC2):
    r"""Proxy of C++ itkImageToImageFilterVIF2IUC2 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(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2IUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2IUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2IUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2IUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2IUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2IUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2IUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2IUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2IUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2IUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterVIF2IUC2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF2IUC2_GetPointer)

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

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

          itkImageToImageFilterVIF2IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterVIF2IUC2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterVIF2IUC2_swigregister(itkImageToImageFilterVIF2IUC2)
class itkImageToImageFilterVIF3IF3(itkImageSourcePython.itkImageSourceIF3):
    r"""Proxy of C++ itkImageToImageFilterVIF3IF3 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(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3IF3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3IF3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3IF3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3IF3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3IF3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3IF3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3IF3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3IF3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3IF3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3IF3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterVIF3IF3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3IF3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3IF3_GetPointer)

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

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

          itkImageToImageFilterVIF3IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterVIF3IF3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterVIF3IF3_swigregister(itkImageToImageFilterVIF3IF3)
class itkImageToImageFilterVIF3ISS3(itkImageSourcePython.itkImageSourceISS3):
    r"""Proxy of C++ itkImageToImageFilterVIF3ISS3 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(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3ISS3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3ISS3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3ISS3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3ISS3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3ISS3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3ISS3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3ISS3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3ISS3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3ISS3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3ISS3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterVIF3ISS3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3ISS3_GetPointer)

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

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

          itkImageToImageFilterVIF3ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterVIF3ISS3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterVIF3ISS3_swigregister(itkImageToImageFilterVIF3ISS3)
class itkImageToImageFilterVIF3IUC3(itkImageSourcePython.itkImageSourceIUC3):
    r"""Proxy of C++ itkImageToImageFilterVIF3IUC3 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(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3IUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3IUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3IUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3IUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3IUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3IUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3IUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3IUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3IUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3IUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterVIF3IUC3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIF3IUC3_GetPointer)

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

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

          itkImageToImageFilterVIF3IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterVIF3IUC3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterVIF3IUC3_swigregister(itkImageToImageFilterVIF3IUC3)
class itkImageToImageFilterVISS2IF2(itkImageSourcePython.itkImageSourceIF2):
    r"""Proxy of C++ itkImageToImageFilterVISS2IF2 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(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2IF2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2IF2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2IF2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2IF2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2IF2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2IF2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2IF2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2IF2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2IF2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2IF2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterVISS2IF2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2IF2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2IF2_GetPointer)

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

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

          itkImageToImageFilterVISS2IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterVISS2IF2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterVISS2IF2_swigregister(itkImageToImageFilterVISS2IF2)
class itkImageToImageFilterVISS2ISS2(itkImageSourcePython.itkImageSourceISS2):
    r"""Proxy of C++ itkImageToImageFilterVISS2ISS2 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(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2ISS2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2ISS2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2ISS2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2ISS2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2ISS2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2ISS2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2ISS2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2ISS2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2ISS2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2ISS2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterVISS2ISS2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2ISS2_GetPointer)

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

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

          itkImageToImageFilterVISS2ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterVISS2ISS2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterVISS2ISS2_swigregister(itkImageToImageFilterVISS2ISS2)
class itkImageToImageFilterVISS2IUC2(itkImageSourcePython.itkImageSourceIUC2):
    r"""Proxy of C++ itkImageToImageFilterVISS2IUC2 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(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2IUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2IUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2IUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2IUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2IUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2IUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2IUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2IUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2IUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2IUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterVISS2IUC2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS2IUC2_GetPointer)

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

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

          itkImageToImageFilterVISS2IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterVISS2IUC2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterVISS2IUC2_swigregister(itkImageToImageFilterVISS2IUC2)
class itkImageToImageFilterVISS3IF3(itkImageSourcePython.itkImageSourceIF3):
    r"""Proxy of C++ itkImageToImageFilterVISS3IF3 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(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3IF3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3IF3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3IF3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3IF3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3IF3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3IF3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3IF3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3IF3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3IF3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3IF3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterVISS3IF3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3IF3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3IF3_GetPointer)

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

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

          itkImageToImageFilterVISS3IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterVISS3IF3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterVISS3IF3_swigregister(itkImageToImageFilterVISS3IF3)
class itkImageToImageFilterVISS3ISS3(itkImageSourcePython.itkImageSourceISS3):
    r"""Proxy of C++ itkImageToImageFilterVISS3ISS3 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(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3ISS3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3ISS3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3ISS3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3ISS3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3ISS3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3ISS3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3ISS3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3ISS3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3ISS3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3ISS3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterVISS3ISS3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3ISS3_GetPointer)

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

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

          itkImageToImageFilterVISS3ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterVISS3ISS3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterVISS3ISS3_swigregister(itkImageToImageFilterVISS3ISS3)
class itkImageToImageFilterVISS3IUC3(itkImageSourcePython.itkImageSourceIUC3):
    r"""Proxy of C++ itkImageToImageFilterVISS3IUC3 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(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3IUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3IUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3IUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3IUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3IUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3IUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3IUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3IUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3IUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3IUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterVISS3IUC3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVISS3IUC3_GetPointer)

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

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

          itkImageToImageFilterVISS3IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterVISS3IUC3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterVISS3IUC3_swigregister(itkImageToImageFilterVISS3IUC3)
class itkImageToImageFilterVIUC2IF2(itkImageSourcePython.itkImageSourceIF2):
    r"""Proxy of C++ itkImageToImageFilterVIUC2IF2 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(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IF2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IF2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IF2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IF2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IF2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IF2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IF2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IF2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IF2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IF2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterVIUC2IF2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IF2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IF2_GetPointer)

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

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

          itkImageToImageFilterVIUC2IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterVIUC2IF2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IF2_swigregister(itkImageToImageFilterVIUC2IF2)
class itkImageToImageFilterVIUC2ISS2(itkImageSourcePython.itkImageSourceISS2):
    r"""Proxy of C++ itkImageToImageFilterVIUC2ISS2 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(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2ISS2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2ISS2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2ISS2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2ISS2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2ISS2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2ISS2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2ISS2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2ISS2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2ISS2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2ISS2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterVIUC2ISS2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2ISS2_GetPointer)

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

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

          itkImageToImageFilterVIUC2ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterVIUC2ISS2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2ISS2_swigregister(itkImageToImageFilterVIUC2ISS2)
class itkImageToImageFilterVIUC2IUC2(itkImageSourcePython.itkImageSourceIUC2):
    r"""Proxy of C++ itkImageToImageFilterVIUC2IUC2 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(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IUC2_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IUC2_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IUC2_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IUC2_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IUC2_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IUC2_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IUC2_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IUC2_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IUC2_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IUC2_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterVIUC2IUC2
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IUC2_GetPointer)

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

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

          itkImageToImageFilterVIUC2IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterVIUC2IUC2 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IUC2_swigregister(itkImageToImageFilterVIUC2IUC2)
class itkImageToImageFilterVIUC3IF3(itkImageSourcePython.itkImageSourceIF3):
    r"""Proxy of C++ itkImageToImageFilterVIUC3IF3 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(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IF3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IF3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IF3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IF3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IF3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IF3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IF3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IF3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IF3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IF3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterVIUC3IF3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IF3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IF3_GetPointer)

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

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

          itkImageToImageFilterVIUC3IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterVIUC3IF3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IF3_swigregister(itkImageToImageFilterVIUC3IF3)
class itkImageToImageFilterVIUC3ISS3(itkImageSourcePython.itkImageSourceISS3):
    r"""Proxy of C++ itkImageToImageFilterVIUC3ISS3 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(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3ISS3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3ISS3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3ISS3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3ISS3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3ISS3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3ISS3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3ISS3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3ISS3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3ISS3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3ISS3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterVIUC3ISS3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3ISS3_GetPointer)

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

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

          itkImageToImageFilterVIUC3ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterVIUC3ISS3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3ISS3_swigregister(itkImageToImageFilterVIUC3ISS3)
class itkImageToImageFilterVIUC3IUC3(itkImageSourcePython.itkImageSourceIUC3):
    r"""Proxy of C++ itkImageToImageFilterVIUC3IUC3 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(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IUC3_SetInput)
    GetInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IUC3_GetInput)
    PushBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IUC3_PushBackInput)
    PopBackInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IUC3_PopBackInput)
    PushFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IUC3_PushFrontInput)
    PopFrontInput = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IUC3_PopFrontInput)
    SetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IUC3_SetCoordinateTolerance)
    GetCoordinateTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IUC3_GetCoordinateTolerance)
    SetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IUC3_SetDirectionTolerance)
    GetDirectionTolerance = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IUC3_GetDirectionTolerance)
    __swig_destroy__ = _itkImageToImageFilterBPython.delete_itkImageToImageFilterVIUC3IUC3
    cast = _swig_new_static_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IUC3_GetPointer)

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

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

          itkImageToImageFilterVIUC3IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToImageFilterVIUC3IUC3 in _itkImageToImageFilterBPython:
_itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IUC3_swigregister(itkImageToImageFilterVIUC3IUC3)

