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

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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

def itkInPlaceImageFilterIF3IRGBAUC3_New():
  return itkInPlaceImageFilterIF3IRGBAUC3.New()


def itkInPlaceImageFilterIF2IRGBAUC2_New():
  return itkInPlaceImageFilterIF2IRGBAUC2.New()


def itkInPlaceImageFilterIUC3IRGBAUC3_New():
  return itkInPlaceImageFilterIUC3IRGBAUC3.New()


def itkInPlaceImageFilterIUC2IRGBAUC2_New():
  return itkInPlaceImageFilterIUC2IRGBAUC2.New()


def itkInPlaceImageFilterISS3IRGBAUC3_New():
  return itkInPlaceImageFilterISS3IRGBAUC3.New()


def itkInPlaceImageFilterISS2IRGBAUC2_New():
  return itkInPlaceImageFilterISS2IRGBAUC2.New()


def itkInPlaceImageFilterIUL3IRGBAUC3_New():
  return itkInPlaceImageFilterIUL3IRGBAUC3.New()


def itkInPlaceImageFilterIUL2IRGBAUC2_New():
  return itkInPlaceImageFilterIUL2IRGBAUC2.New()


def itkInPlaceImageFilterIRGBAUC3IUC3_New():
  return itkInPlaceImageFilterIRGBAUC3IUC3.New()


def itkInPlaceImageFilterIRGBAUC2IUC2_New():
  return itkInPlaceImageFilterIRGBAUC2IUC2.New()


def itkInPlaceImageFilterIRGBAUC3IRGBAUC3_New():
  return itkInPlaceImageFilterIRGBAUC3IRGBAUC3.New()


def itkInPlaceImageFilterIRGBAUC2IRGBAUC2_New():
  return itkInPlaceImageFilterIRGBAUC2IRGBAUC2.New()


def itkInPlaceImageFilterIF3IRGBUC3_New():
  return itkInPlaceImageFilterIF3IRGBUC3.New()


def itkInPlaceImageFilterIF2IRGBUC2_New():
  return itkInPlaceImageFilterIF2IRGBUC2.New()


def itkInPlaceImageFilterIUC3IRGBUC3_New():
  return itkInPlaceImageFilterIUC3IRGBUC3.New()


def itkInPlaceImageFilterIUC2IRGBUC2_New():
  return itkInPlaceImageFilterIUC2IRGBUC2.New()


def itkInPlaceImageFilterISS3IRGBUC3_New():
  return itkInPlaceImageFilterISS3IRGBUC3.New()


def itkInPlaceImageFilterISS2IRGBUC2_New():
  return itkInPlaceImageFilterISS2IRGBUC2.New()


def itkInPlaceImageFilterIUL3IRGBUC3_New():
  return itkInPlaceImageFilterIUL3IRGBUC3.New()


def itkInPlaceImageFilterIUL2IRGBUC2_New():
  return itkInPlaceImageFilterIUL2IRGBUC2.New()


def itkInPlaceImageFilterIRGBUC3IUC3_New():
  return itkInPlaceImageFilterIRGBUC3IUC3.New()


def itkInPlaceImageFilterIRGBUC2IUC2_New():
  return itkInPlaceImageFilterIRGBUC2IUC2.New()


def itkInPlaceImageFilterIRGBUC3IRGBUC3_New():
  return itkInPlaceImageFilterIRGBUC3IRGBUC3.New()


def itkInPlaceImageFilterIRGBUC2IRGBUC2_New():
  return itkInPlaceImageFilterIRGBUC2IRGBUC2.New()


def itkInPlaceImageFilterICVF43ICVF43_New():
  return itkInPlaceImageFilterICVF43ICVF43.New()


def itkInPlaceImageFilterICVF42ICVF42_New():
  return itkInPlaceImageFilterICVF42ICVF42.New()


def itkInPlaceImageFilterICVF33ICVF33_New():
  return itkInPlaceImageFilterICVF33ICVF33.New()


def itkInPlaceImageFilterICVF32ICVF32_New():
  return itkInPlaceImageFilterICVF32ICVF32.New()


def itkInPlaceImageFilterICVF23ICVF23_New():
  return itkInPlaceImageFilterICVF23ICVF23.New()


def itkInPlaceImageFilterICVF22ICVF22_New():
  return itkInPlaceImageFilterICVF22ICVF22.New()


def itkInPlaceImageFilterICVF43IVF43_New():
  return itkInPlaceImageFilterICVF43IVF43.New()


def itkInPlaceImageFilterICVF42IVF42_New():
  return itkInPlaceImageFilterICVF42IVF42.New()


def itkInPlaceImageFilterICVF33IVF33_New():
  return itkInPlaceImageFilterICVF33IVF33.New()


def itkInPlaceImageFilterICVF32IVF32_New():
  return itkInPlaceImageFilterICVF32IVF32.New()


def itkInPlaceImageFilterICVF23IVF23_New():
  return itkInPlaceImageFilterICVF23IVF23.New()


def itkInPlaceImageFilterICVF22IVF22_New():
  return itkInPlaceImageFilterICVF22IVF22.New()


def itkInPlaceImageFilterIVF43ICVF43_New():
  return itkInPlaceImageFilterIVF43ICVF43.New()


def itkInPlaceImageFilterIVF42ICVF42_New():
  return itkInPlaceImageFilterIVF42ICVF42.New()


def itkInPlaceImageFilterIVF33ICVF33_New():
  return itkInPlaceImageFilterIVF33ICVF33.New()


def itkInPlaceImageFilterIVF32ICVF32_New():
  return itkInPlaceImageFilterIVF32ICVF32.New()


def itkInPlaceImageFilterIVF23ICVF23_New():
  return itkInPlaceImageFilterIVF23ICVF23.New()


def itkInPlaceImageFilterIVF22ICVF22_New():
  return itkInPlaceImageFilterIVF22ICVF22.New()


def itkInPlaceImageFilterIVF43IVF43_New():
  return itkInPlaceImageFilterIVF43IVF43.New()


def itkInPlaceImageFilterIVF42IVF42_New():
  return itkInPlaceImageFilterIVF42IVF42.New()


def itkInPlaceImageFilterIVF33IVF33_New():
  return itkInPlaceImageFilterIVF33IVF33.New()


def itkInPlaceImageFilterIVF32IVF32_New():
  return itkInPlaceImageFilterIVF32IVF32.New()


def itkInPlaceImageFilterIVF23IVF23_New():
  return itkInPlaceImageFilterIVF23IVF23.New()


def itkInPlaceImageFilterIVF22IVF22_New():
  return itkInPlaceImageFilterIVF22IVF22.New()


def itkInPlaceImageFilterIUL3IUC3_New():
  return itkInPlaceImageFilterIUL3IUC3.New()


def itkInPlaceImageFilterIUL2IUC2_New():
  return itkInPlaceImageFilterIUL2IUC2.New()


def itkInPlaceImageFilterIUL3ISS3_New():
  return itkInPlaceImageFilterIUL3ISS3.New()


def itkInPlaceImageFilterIUL2ISS2_New():
  return itkInPlaceImageFilterIUL2ISS2.New()


def itkInPlaceImageFilterIF3IF3_New():
  return itkInPlaceImageFilterIF3IF3.New()


def itkInPlaceImageFilterIF2IF2_New():
  return itkInPlaceImageFilterIF2IF2.New()


def itkInPlaceImageFilterIF3ISS3_New():
  return itkInPlaceImageFilterIF3ISS3.New()


def itkInPlaceImageFilterIF2ISS2_New():
  return itkInPlaceImageFilterIF2ISS2.New()


def itkInPlaceImageFilterIF3IUC3_New():
  return itkInPlaceImageFilterIF3IUC3.New()


def itkInPlaceImageFilterIF2IUC2_New():
  return itkInPlaceImageFilterIF2IUC2.New()


def itkInPlaceImageFilterISS3IF3_New():
  return itkInPlaceImageFilterISS3IF3.New()


def itkInPlaceImageFilterISS2IF2_New():
  return itkInPlaceImageFilterISS2IF2.New()


def itkInPlaceImageFilterISS3ISS3_New():
  return itkInPlaceImageFilterISS3ISS3.New()


def itkInPlaceImageFilterISS2ISS2_New():
  return itkInPlaceImageFilterISS2ISS2.New()


def itkInPlaceImageFilterISS3IUC3_New():
  return itkInPlaceImageFilterISS3IUC3.New()


def itkInPlaceImageFilterISS2IUC2_New():
  return itkInPlaceImageFilterISS2IUC2.New()


def itkInPlaceImageFilterIUC3IF3_New():
  return itkInPlaceImageFilterIUC3IF3.New()


def itkInPlaceImageFilterIUC2IF2_New():
  return itkInPlaceImageFilterIUC2IF2.New()


def itkInPlaceImageFilterIUC3ISS3_New():
  return itkInPlaceImageFilterIUC3ISS3.New()


def itkInPlaceImageFilterIUC2ISS2_New():
  return itkInPlaceImageFilterIUC2ISS2.New()


def itkInPlaceImageFilterIUC3IUC3_New():
  return itkInPlaceImageFilterIUC3IUC3.New()


def itkInPlaceImageFilterIUC2IUC2_New():
  return itkInPlaceImageFilterIUC2IUC2.New()

class itkInPlaceImageFilterICVF22ICVF22(itkImageToImageFilterAPython.itkImageToImageFilterICVF22ICVF22):
    r"""Proxy of C++ itkInPlaceImageFilterICVF22ICVF22 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF22ICVF22_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF22ICVF22_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF22ICVF22_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF22ICVF22_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF22ICVF22_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterICVF22ICVF22
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF22ICVF22_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF22ICVF22_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterICVF22ICVF22 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterICVF22ICVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF22ICVF22 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF22ICVF22_swigregister(itkInPlaceImageFilterICVF22ICVF22)
class itkInPlaceImageFilterICVF22IVF22(itkImageToImageFilterAPython.itkImageToImageFilterICVF22IVF22):
    r"""Proxy of C++ itkInPlaceImageFilterICVF22IVF22 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF22IVF22_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF22IVF22_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF22IVF22_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF22IVF22_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF22IVF22_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterICVF22IVF22
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF22IVF22_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF22IVF22_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterICVF22IVF22 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterICVF22IVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF22IVF22 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF22IVF22_swigregister(itkInPlaceImageFilterICVF22IVF22)
class itkInPlaceImageFilterICVF23ICVF23(itkImageToImageFilterAPython.itkImageToImageFilterICVF23ICVF23):
    r"""Proxy of C++ itkInPlaceImageFilterICVF23ICVF23 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF23ICVF23_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF23ICVF23_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF23ICVF23_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF23ICVF23_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF23ICVF23_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterICVF23ICVF23
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF23ICVF23_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF23ICVF23_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterICVF23ICVF23 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterICVF23ICVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF23ICVF23 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF23ICVF23_swigregister(itkInPlaceImageFilterICVF23ICVF23)
class itkInPlaceImageFilterICVF23IVF23(itkImageToImageFilterAPython.itkImageToImageFilterICVF23IVF23):
    r"""Proxy of C++ itkInPlaceImageFilterICVF23IVF23 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF23IVF23_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF23IVF23_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF23IVF23_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF23IVF23_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF23IVF23_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterICVF23IVF23
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF23IVF23_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF23IVF23_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterICVF23IVF23 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterICVF23IVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF23IVF23 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF23IVF23_swigregister(itkInPlaceImageFilterICVF23IVF23)
class itkInPlaceImageFilterICVF32ICVF32(itkImageToImageFilterAPython.itkImageToImageFilterICVF32ICVF32):
    r"""Proxy of C++ itkInPlaceImageFilterICVF32ICVF32 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF32ICVF32_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF32ICVF32_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF32ICVF32_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF32ICVF32_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF32ICVF32_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterICVF32ICVF32
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF32ICVF32_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF32ICVF32_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterICVF32ICVF32 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterICVF32ICVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF32ICVF32 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF32ICVF32_swigregister(itkInPlaceImageFilterICVF32ICVF32)
class itkInPlaceImageFilterICVF32IVF32(itkImageToImageFilterAPython.itkImageToImageFilterICVF32IVF32):
    r"""Proxy of C++ itkInPlaceImageFilterICVF32IVF32 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF32IVF32_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF32IVF32_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF32IVF32_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF32IVF32_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF32IVF32_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterICVF32IVF32
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF32IVF32_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF32IVF32_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterICVF32IVF32 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterICVF32IVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF32IVF32 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF32IVF32_swigregister(itkInPlaceImageFilterICVF32IVF32)
class itkInPlaceImageFilterICVF33ICVF33(itkImageToImageFilterAPython.itkImageToImageFilterICVF33ICVF33):
    r"""Proxy of C++ itkInPlaceImageFilterICVF33ICVF33 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF33ICVF33_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF33ICVF33_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF33ICVF33_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF33ICVF33_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF33ICVF33_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterICVF33ICVF33
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF33ICVF33_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF33ICVF33_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterICVF33ICVF33 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterICVF33ICVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF33ICVF33 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF33ICVF33_swigregister(itkInPlaceImageFilterICVF33ICVF33)
class itkInPlaceImageFilterICVF33IVF33(itkImageToImageFilterAPython.itkImageToImageFilterICVF33IVF33):
    r"""Proxy of C++ itkInPlaceImageFilterICVF33IVF33 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF33IVF33_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF33IVF33_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF33IVF33_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF33IVF33_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF33IVF33_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterICVF33IVF33
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF33IVF33_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF33IVF33_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterICVF33IVF33 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterICVF33IVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF33IVF33 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF33IVF33_swigregister(itkInPlaceImageFilterICVF33IVF33)
class itkInPlaceImageFilterICVF42ICVF42(itkImageToImageFilterAPython.itkImageToImageFilterICVF42ICVF42):
    r"""Proxy of C++ itkInPlaceImageFilterICVF42ICVF42 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF42ICVF42_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF42ICVF42_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF42ICVF42_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF42ICVF42_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF42ICVF42_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterICVF42ICVF42
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF42ICVF42_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF42ICVF42_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterICVF42ICVF42 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterICVF42ICVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF42ICVF42 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF42ICVF42_swigregister(itkInPlaceImageFilterICVF42ICVF42)
class itkInPlaceImageFilterICVF42IVF42(itkImageToImageFilterAPython.itkImageToImageFilterICVF42IVF42):
    r"""Proxy of C++ itkInPlaceImageFilterICVF42IVF42 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF42IVF42_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF42IVF42_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF42IVF42_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF42IVF42_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF42IVF42_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterICVF42IVF42
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF42IVF42_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF42IVF42_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterICVF42IVF42 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterICVF42IVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF42IVF42 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF42IVF42_swigregister(itkInPlaceImageFilterICVF42IVF42)
class itkInPlaceImageFilterICVF43ICVF43(itkImageToImageFilterAPython.itkImageToImageFilterICVF43ICVF43):
    r"""Proxy of C++ itkInPlaceImageFilterICVF43ICVF43 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF43ICVF43_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF43ICVF43_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF43ICVF43_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF43ICVF43_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF43ICVF43_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterICVF43ICVF43
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF43ICVF43_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF43ICVF43_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterICVF43ICVF43 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterICVF43ICVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF43ICVF43 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF43ICVF43_swigregister(itkInPlaceImageFilterICVF43ICVF43)
class itkInPlaceImageFilterICVF43IVF43(itkImageToImageFilterAPython.itkImageToImageFilterICVF43IVF43):
    r"""Proxy of C++ itkInPlaceImageFilterICVF43IVF43 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF43IVF43_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF43IVF43_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF43IVF43_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF43IVF43_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF43IVF43_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterICVF43IVF43
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF43IVF43_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF43IVF43_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterICVF43IVF43 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterICVF43IVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF43IVF43 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF43IVF43_swigregister(itkInPlaceImageFilterICVF43IVF43)
class itkInPlaceImageFilterIF2IF2(itkImageToImageFilterAPython.itkImageToImageFilterIF2IF2):
    r"""Proxy of C++ itkInPlaceImageFilterIF2IF2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IF2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IF2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IF2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IF2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IF2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIF2IF2
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IF2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IF2_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIF2IF2 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIF2IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF2IF2 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IF2_swigregister(itkInPlaceImageFilterIF2IF2)
class itkInPlaceImageFilterIF2IRGBAUC2(itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBAUC2):
    r"""Proxy of C++ itkInPlaceImageFilterIF2IRGBAUC2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IRGBAUC2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IRGBAUC2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IRGBAUC2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IRGBAUC2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IRGBAUC2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIF2IRGBAUC2
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IRGBAUC2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IRGBAUC2_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIF2IRGBAUC2 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIF2IRGBAUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF2IRGBAUC2 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IRGBAUC2_swigregister(itkInPlaceImageFilterIF2IRGBAUC2)
class itkInPlaceImageFilterIF2IRGBUC2(itkImageToImageFilterBPython.itkImageToImageFilterIF2IRGBUC2):
    r"""Proxy of C++ itkInPlaceImageFilterIF2IRGBUC2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IRGBUC2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IRGBUC2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IRGBUC2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IRGBUC2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IRGBUC2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIF2IRGBUC2
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IRGBUC2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IRGBUC2_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIF2IRGBUC2 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIF2IRGBUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF2IRGBUC2 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IRGBUC2_swigregister(itkInPlaceImageFilterIF2IRGBUC2)
class itkInPlaceImageFilterIF2ISS2(itkImageToImageFilterAPython.itkImageToImageFilterIF2ISS2):
    r"""Proxy of C++ itkInPlaceImageFilterIF2ISS2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2ISS2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2ISS2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2ISS2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2ISS2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2ISS2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIF2ISS2
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2ISS2_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIF2ISS2 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIF2ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF2ISS2 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2ISS2_swigregister(itkInPlaceImageFilterIF2ISS2)
class itkInPlaceImageFilterIF2IUC2(itkImageToImageFilterAPython.itkImageToImageFilterIF2IUC2):
    r"""Proxy of C++ itkInPlaceImageFilterIF2IUC2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IUC2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IUC2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IUC2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IUC2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IUC2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIF2IUC2
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IUC2_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIF2IUC2 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIF2IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF2IUC2 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IUC2_swigregister(itkInPlaceImageFilterIF2IUC2)
class itkInPlaceImageFilterIF3IF3(itkImageToImageFilterAPython.itkImageToImageFilterIF3IF3):
    r"""Proxy of C++ itkInPlaceImageFilterIF3IF3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IF3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IF3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IF3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IF3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IF3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIF3IF3
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IF3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IF3_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIF3IF3 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIF3IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF3IF3 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IF3_swigregister(itkInPlaceImageFilterIF3IF3)
class itkInPlaceImageFilterIF3IRGBAUC3(itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBAUC3):
    r"""Proxy of C++ itkInPlaceImageFilterIF3IRGBAUC3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IRGBAUC3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IRGBAUC3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IRGBAUC3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IRGBAUC3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IRGBAUC3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIF3IRGBAUC3
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IRGBAUC3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IRGBAUC3_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIF3IRGBAUC3 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIF3IRGBAUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF3IRGBAUC3 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IRGBAUC3_swigregister(itkInPlaceImageFilterIF3IRGBAUC3)
class itkInPlaceImageFilterIF3IRGBUC3(itkImageToImageFilterBPython.itkImageToImageFilterIF3IRGBUC3):
    r"""Proxy of C++ itkInPlaceImageFilterIF3IRGBUC3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IRGBUC3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IRGBUC3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IRGBUC3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IRGBUC3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IRGBUC3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIF3IRGBUC3
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IRGBUC3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IRGBUC3_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIF3IRGBUC3 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIF3IRGBUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF3IRGBUC3 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IRGBUC3_swigregister(itkInPlaceImageFilterIF3IRGBUC3)
class itkInPlaceImageFilterIF3ISS3(itkImageToImageFilterAPython.itkImageToImageFilterIF3ISS3):
    r"""Proxy of C++ itkInPlaceImageFilterIF3ISS3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3ISS3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3ISS3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3ISS3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3ISS3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3ISS3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIF3ISS3
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3ISS3_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIF3ISS3 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIF3ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF3ISS3 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3ISS3_swigregister(itkInPlaceImageFilterIF3ISS3)
class itkInPlaceImageFilterIF3IUC3(itkImageToImageFilterAPython.itkImageToImageFilterIF3IUC3):
    r"""Proxy of C++ itkInPlaceImageFilterIF3IUC3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IUC3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IUC3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IUC3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IUC3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IUC3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIF3IUC3
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IUC3_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIF3IUC3 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIF3IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF3IUC3 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IUC3_swigregister(itkInPlaceImageFilterIF3IUC3)
class itkInPlaceImageFilterIRGBAUC2IRGBAUC2(itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC2IRGBAUC2):
    r"""Proxy of C++ itkInPlaceImageFilterIRGBAUC2IRGBAUC2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC2IRGBAUC2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC2IRGBAUC2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC2IRGBAUC2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC2IRGBAUC2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC2IRGBAUC2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIRGBAUC2IRGBAUC2
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC2IRGBAUC2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC2IRGBAUC2_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIRGBAUC2IRGBAUC2 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIRGBAUC2IRGBAUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIRGBAUC2IRGBAUC2 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC2IRGBAUC2_swigregister(itkInPlaceImageFilterIRGBAUC2IRGBAUC2)
class itkInPlaceImageFilterIRGBAUC2IUC2(itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUC2):
    r"""Proxy of C++ itkInPlaceImageFilterIRGBAUC2IUC2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC2IUC2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC2IUC2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC2IUC2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC2IUC2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC2IUC2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIRGBAUC2IUC2
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC2IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC2IUC2_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIRGBAUC2IUC2 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIRGBAUC2IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIRGBAUC2IUC2 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC2IUC2_swigregister(itkInPlaceImageFilterIRGBAUC2IUC2)
class itkInPlaceImageFilterIRGBAUC3IRGBAUC3(itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC3IRGBAUC3):
    r"""Proxy of C++ itkInPlaceImageFilterIRGBAUC3IRGBAUC3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC3IRGBAUC3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC3IRGBAUC3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC3IRGBAUC3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC3IRGBAUC3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC3IRGBAUC3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIRGBAUC3IRGBAUC3
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC3IRGBAUC3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC3IRGBAUC3_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIRGBAUC3IRGBAUC3 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIRGBAUC3IRGBAUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIRGBAUC3IRGBAUC3 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC3IRGBAUC3_swigregister(itkInPlaceImageFilterIRGBAUC3IRGBAUC3)
class itkInPlaceImageFilterIRGBAUC3IUC3(itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUC3):
    r"""Proxy of C++ itkInPlaceImageFilterIRGBAUC3IUC3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC3IUC3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC3IUC3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC3IUC3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC3IUC3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC3IUC3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIRGBAUC3IUC3
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC3IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC3IUC3_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIRGBAUC3IUC3 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIRGBAUC3IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIRGBAUC3IUC3 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC3IUC3_swigregister(itkInPlaceImageFilterIRGBAUC3IUC3)
class itkInPlaceImageFilterIRGBUC2IRGBUC2(itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC2IRGBUC2):
    r"""Proxy of C++ itkInPlaceImageFilterIRGBUC2IRGBUC2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC2IRGBUC2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC2IRGBUC2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC2IRGBUC2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC2IRGBUC2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC2IRGBUC2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIRGBUC2IRGBUC2
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC2IRGBUC2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC2IRGBUC2_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIRGBUC2IRGBUC2 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIRGBUC2IRGBUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIRGBUC2IRGBUC2 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC2IRGBUC2_swigregister(itkInPlaceImageFilterIRGBUC2IRGBUC2)
class itkInPlaceImageFilterIRGBUC2IUC2(itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUC2):
    r"""Proxy of C++ itkInPlaceImageFilterIRGBUC2IUC2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC2IUC2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC2IUC2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC2IUC2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC2IUC2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC2IUC2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIRGBUC2IUC2
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC2IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC2IUC2_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIRGBUC2IUC2 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIRGBUC2IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIRGBUC2IUC2 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC2IUC2_swigregister(itkInPlaceImageFilterIRGBUC2IUC2)
class itkInPlaceImageFilterIRGBUC3IRGBUC3(itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC3IRGBUC3):
    r"""Proxy of C++ itkInPlaceImageFilterIRGBUC3IRGBUC3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC3IRGBUC3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC3IRGBUC3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC3IRGBUC3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC3IRGBUC3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC3IRGBUC3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIRGBUC3IRGBUC3
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC3IRGBUC3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC3IRGBUC3_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIRGBUC3IRGBUC3 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIRGBUC3IRGBUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIRGBUC3IRGBUC3 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC3IRGBUC3_swigregister(itkInPlaceImageFilterIRGBUC3IRGBUC3)
class itkInPlaceImageFilterIRGBUC3IUC3(itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUC3):
    r"""Proxy of C++ itkInPlaceImageFilterIRGBUC3IUC3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC3IUC3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC3IUC3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC3IUC3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC3IUC3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC3IUC3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIRGBUC3IUC3
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC3IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC3IUC3_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIRGBUC3IUC3 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIRGBUC3IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIRGBUC3IUC3 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC3IUC3_swigregister(itkInPlaceImageFilterIRGBUC3IUC3)
class itkInPlaceImageFilterISS2IF2(itkImageToImageFilterAPython.itkImageToImageFilterISS2IF2):
    r"""Proxy of C++ itkInPlaceImageFilterISS2IF2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IF2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IF2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IF2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IF2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IF2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterISS2IF2
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IF2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IF2_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterISS2IF2 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterISS2IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterISS2IF2 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IF2_swigregister(itkInPlaceImageFilterISS2IF2)
class itkInPlaceImageFilterISS2IRGBAUC2(itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBAUC2):
    r"""Proxy of C++ itkInPlaceImageFilterISS2IRGBAUC2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IRGBAUC2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IRGBAUC2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IRGBAUC2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IRGBAUC2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IRGBAUC2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterISS2IRGBAUC2
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IRGBAUC2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IRGBAUC2_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterISS2IRGBAUC2 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterISS2IRGBAUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterISS2IRGBAUC2 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IRGBAUC2_swigregister(itkInPlaceImageFilterISS2IRGBAUC2)
class itkInPlaceImageFilterISS2IRGBUC2(itkImageToImageFilterBPython.itkImageToImageFilterISS2IRGBUC2):
    r"""Proxy of C++ itkInPlaceImageFilterISS2IRGBUC2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IRGBUC2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IRGBUC2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IRGBUC2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IRGBUC2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IRGBUC2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterISS2IRGBUC2
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IRGBUC2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IRGBUC2_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterISS2IRGBUC2 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterISS2IRGBUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterISS2IRGBUC2 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IRGBUC2_swigregister(itkInPlaceImageFilterISS2IRGBUC2)
class itkInPlaceImageFilterISS2ISS2(itkImageToImageFilterAPython.itkImageToImageFilterISS2ISS2):
    r"""Proxy of C++ itkInPlaceImageFilterISS2ISS2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2ISS2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2ISS2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2ISS2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2ISS2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2ISS2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterISS2ISS2
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2ISS2_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterISS2ISS2 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterISS2ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterISS2ISS2 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2ISS2_swigregister(itkInPlaceImageFilterISS2ISS2)
class itkInPlaceImageFilterISS2IUC2(itkImageToImageFilterAPython.itkImageToImageFilterISS2IUC2):
    r"""Proxy of C++ itkInPlaceImageFilterISS2IUC2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IUC2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IUC2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IUC2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IUC2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IUC2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterISS2IUC2
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IUC2_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterISS2IUC2 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterISS2IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterISS2IUC2 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2IUC2_swigregister(itkInPlaceImageFilterISS2IUC2)
class itkInPlaceImageFilterISS3IF3(itkImageToImageFilterAPython.itkImageToImageFilterISS3IF3):
    r"""Proxy of C++ itkInPlaceImageFilterISS3IF3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IF3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IF3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IF3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IF3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IF3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterISS3IF3
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IF3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IF3_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterISS3IF3 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterISS3IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterISS3IF3 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IF3_swigregister(itkInPlaceImageFilterISS3IF3)
class itkInPlaceImageFilterISS3IRGBAUC3(itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBAUC3):
    r"""Proxy of C++ itkInPlaceImageFilterISS3IRGBAUC3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IRGBAUC3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IRGBAUC3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IRGBAUC3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IRGBAUC3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IRGBAUC3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterISS3IRGBAUC3
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IRGBAUC3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IRGBAUC3_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterISS3IRGBAUC3 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterISS3IRGBAUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterISS3IRGBAUC3 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IRGBAUC3_swigregister(itkInPlaceImageFilterISS3IRGBAUC3)
class itkInPlaceImageFilterISS3IRGBUC3(itkImageToImageFilterBPython.itkImageToImageFilterISS3IRGBUC3):
    r"""Proxy of C++ itkInPlaceImageFilterISS3IRGBUC3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IRGBUC3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IRGBUC3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IRGBUC3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IRGBUC3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IRGBUC3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterISS3IRGBUC3
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IRGBUC3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IRGBUC3_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterISS3IRGBUC3 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterISS3IRGBUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterISS3IRGBUC3 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IRGBUC3_swigregister(itkInPlaceImageFilterISS3IRGBUC3)
class itkInPlaceImageFilterISS3ISS3(itkImageToImageFilterAPython.itkImageToImageFilterISS3ISS3):
    r"""Proxy of C++ itkInPlaceImageFilterISS3ISS3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3ISS3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3ISS3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3ISS3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3ISS3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3ISS3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterISS3ISS3
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3ISS3_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterISS3ISS3 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterISS3ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterISS3ISS3 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3ISS3_swigregister(itkInPlaceImageFilterISS3ISS3)
class itkInPlaceImageFilterISS3IUC3(itkImageToImageFilterAPython.itkImageToImageFilterISS3IUC3):
    r"""Proxy of C++ itkInPlaceImageFilterISS3IUC3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IUC3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IUC3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IUC3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IUC3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IUC3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterISS3IUC3
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IUC3_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterISS3IUC3 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterISS3IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterISS3IUC3 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3IUC3_swigregister(itkInPlaceImageFilterISS3IUC3)
class itkInPlaceImageFilterIUC2IF2(itkImageToImageFilterAPython.itkImageToImageFilterIUC2IF2):
    r"""Proxy of C++ itkInPlaceImageFilterIUC2IF2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IF2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IF2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IF2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IF2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IF2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIUC2IF2
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IF2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IF2_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIUC2IF2 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIUC2IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUC2IF2 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IF2_swigregister(itkInPlaceImageFilterIUC2IF2)
class itkInPlaceImageFilterIUC2IRGBAUC2(itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBAUC2):
    r"""Proxy of C++ itkInPlaceImageFilterIUC2IRGBAUC2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IRGBAUC2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IRGBAUC2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IRGBAUC2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IRGBAUC2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IRGBAUC2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIUC2IRGBAUC2
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IRGBAUC2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IRGBAUC2_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIUC2IRGBAUC2 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIUC2IRGBAUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUC2IRGBAUC2 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IRGBAUC2_swigregister(itkInPlaceImageFilterIUC2IRGBAUC2)
class itkInPlaceImageFilterIUC2IRGBUC2(itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBUC2):
    r"""Proxy of C++ itkInPlaceImageFilterIUC2IRGBUC2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IRGBUC2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IRGBUC2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IRGBUC2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IRGBUC2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IRGBUC2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIUC2IRGBUC2
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IRGBUC2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IRGBUC2_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIUC2IRGBUC2 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIUC2IRGBUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUC2IRGBUC2 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IRGBUC2_swigregister(itkInPlaceImageFilterIUC2IRGBUC2)
class itkInPlaceImageFilterIUC2ISS2(itkImageToImageFilterAPython.itkImageToImageFilterIUC2ISS2):
    r"""Proxy of C++ itkInPlaceImageFilterIUC2ISS2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2ISS2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2ISS2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2ISS2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2ISS2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2ISS2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIUC2ISS2
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2ISS2_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIUC2ISS2 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIUC2ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUC2ISS2 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2ISS2_swigregister(itkInPlaceImageFilterIUC2ISS2)
class itkInPlaceImageFilterIUC2IUC2(itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUC2):
    r"""Proxy of C++ itkInPlaceImageFilterIUC2IUC2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IUC2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IUC2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IUC2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IUC2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IUC2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIUC2IUC2
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IUC2_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIUC2IUC2 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIUC2IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUC2IUC2 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IUC2_swigregister(itkInPlaceImageFilterIUC2IUC2)
class itkInPlaceImageFilterIUC3IF3(itkImageToImageFilterAPython.itkImageToImageFilterIUC3IF3):
    r"""Proxy of C++ itkInPlaceImageFilterIUC3IF3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IF3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IF3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IF3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IF3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IF3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIUC3IF3
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IF3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IF3_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIUC3IF3 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIUC3IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUC3IF3 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IF3_swigregister(itkInPlaceImageFilterIUC3IF3)
class itkInPlaceImageFilterIUC3IRGBAUC3(itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBAUC3):
    r"""Proxy of C++ itkInPlaceImageFilterIUC3IRGBAUC3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IRGBAUC3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IRGBAUC3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IRGBAUC3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IRGBAUC3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IRGBAUC3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIUC3IRGBAUC3
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IRGBAUC3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IRGBAUC3_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIUC3IRGBAUC3 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIUC3IRGBAUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUC3IRGBAUC3 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IRGBAUC3_swigregister(itkInPlaceImageFilterIUC3IRGBAUC3)
class itkInPlaceImageFilterIUC3IRGBUC3(itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBUC3):
    r"""Proxy of C++ itkInPlaceImageFilterIUC3IRGBUC3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IRGBUC3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IRGBUC3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IRGBUC3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IRGBUC3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IRGBUC3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIUC3IRGBUC3
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IRGBUC3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IRGBUC3_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIUC3IRGBUC3 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIUC3IRGBUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUC3IRGBUC3 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IRGBUC3_swigregister(itkInPlaceImageFilterIUC3IRGBUC3)
class itkInPlaceImageFilterIUC3ISS3(itkImageToImageFilterAPython.itkImageToImageFilterIUC3ISS3):
    r"""Proxy of C++ itkInPlaceImageFilterIUC3ISS3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3ISS3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3ISS3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3ISS3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3ISS3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3ISS3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIUC3ISS3
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3ISS3_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIUC3ISS3 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIUC3ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUC3ISS3 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3ISS3_swigregister(itkInPlaceImageFilterIUC3ISS3)
class itkInPlaceImageFilterIUC3IUC3(itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUC3):
    r"""Proxy of C++ itkInPlaceImageFilterIUC3IUC3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IUC3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IUC3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IUC3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IUC3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IUC3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIUC3IUC3
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IUC3_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIUC3IUC3 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIUC3IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUC3IUC3 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IUC3_swigregister(itkInPlaceImageFilterIUC3IUC3)
class itkInPlaceImageFilterIUL2IRGBAUC2(itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBAUC2):
    r"""Proxy of C++ itkInPlaceImageFilterIUL2IRGBAUC2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2IRGBAUC2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2IRGBAUC2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2IRGBAUC2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2IRGBAUC2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2IRGBAUC2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIUL2IRGBAUC2
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2IRGBAUC2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2IRGBAUC2_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIUL2IRGBAUC2 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIUL2IRGBAUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUL2IRGBAUC2 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2IRGBAUC2_swigregister(itkInPlaceImageFilterIUL2IRGBAUC2)
class itkInPlaceImageFilterIUL2IRGBUC2(itkImageToImageFilterBPython.itkImageToImageFilterIUL2IRGBUC2):
    r"""Proxy of C++ itkInPlaceImageFilterIUL2IRGBUC2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2IRGBUC2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2IRGBUC2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2IRGBUC2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2IRGBUC2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2IRGBUC2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIUL2IRGBUC2
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2IRGBUC2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2IRGBUC2_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIUL2IRGBUC2 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIUL2IRGBUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUL2IRGBUC2 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2IRGBUC2_swigregister(itkInPlaceImageFilterIUL2IRGBUC2)
class itkInPlaceImageFilterIUL2ISS2(itkImageToImageFilterAPython.itkImageToImageFilterIUL2ISS2):
    r"""Proxy of C++ itkInPlaceImageFilterIUL2ISS2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2ISS2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2ISS2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2ISS2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2ISS2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2ISS2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIUL2ISS2
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2ISS2_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIUL2ISS2 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIUL2ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUL2ISS2 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2ISS2_swigregister(itkInPlaceImageFilterIUL2ISS2)
class itkInPlaceImageFilterIUL2IUC2(itkImageToImageFilterAPython.itkImageToImageFilterIUL2IUC2):
    r"""Proxy of C++ itkInPlaceImageFilterIUL2IUC2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2IUC2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2IUC2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2IUC2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2IUC2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2IUC2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIUL2IUC2
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2IUC2_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIUL2IUC2 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIUL2IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUL2IUC2 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL2IUC2_swigregister(itkInPlaceImageFilterIUL2IUC2)
class itkInPlaceImageFilterIUL3IRGBAUC3(itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBAUC3):
    r"""Proxy of C++ itkInPlaceImageFilterIUL3IRGBAUC3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3IRGBAUC3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3IRGBAUC3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3IRGBAUC3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3IRGBAUC3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3IRGBAUC3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIUL3IRGBAUC3
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3IRGBAUC3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3IRGBAUC3_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIUL3IRGBAUC3 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIUL3IRGBAUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUL3IRGBAUC3 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3IRGBAUC3_swigregister(itkInPlaceImageFilterIUL3IRGBAUC3)
class itkInPlaceImageFilterIUL3IRGBUC3(itkImageToImageFilterBPython.itkImageToImageFilterIUL3IRGBUC3):
    r"""Proxy of C++ itkInPlaceImageFilterIUL3IRGBUC3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3IRGBUC3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3IRGBUC3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3IRGBUC3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3IRGBUC3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3IRGBUC3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIUL3IRGBUC3
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3IRGBUC3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3IRGBUC3_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIUL3IRGBUC3 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIUL3IRGBUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUL3IRGBUC3 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3IRGBUC3_swigregister(itkInPlaceImageFilterIUL3IRGBUC3)
class itkInPlaceImageFilterIUL3ISS3(itkImageToImageFilterAPython.itkImageToImageFilterIUL3ISS3):
    r"""Proxy of C++ itkInPlaceImageFilterIUL3ISS3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3ISS3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3ISS3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3ISS3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3ISS3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3ISS3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIUL3ISS3
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3ISS3_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIUL3ISS3 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIUL3ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUL3ISS3 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3ISS3_swigregister(itkInPlaceImageFilterIUL3ISS3)
class itkInPlaceImageFilterIUL3IUC3(itkImageToImageFilterAPython.itkImageToImageFilterIUL3IUC3):
    r"""Proxy of C++ itkInPlaceImageFilterIUL3IUC3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3IUC3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3IUC3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3IUC3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3IUC3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3IUC3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIUL3IUC3
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3IUC3_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIUL3IUC3 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIUL3IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUL3IUC3 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUL3IUC3_swigregister(itkInPlaceImageFilterIUL3IUC3)
class itkInPlaceImageFilterIVF22ICVF22(itkImageToImageFilterAPython.itkImageToImageFilterIVF22ICVF22):
    r"""Proxy of C++ itkInPlaceImageFilterIVF22ICVF22 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF22ICVF22_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF22ICVF22_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF22ICVF22_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF22ICVF22_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF22ICVF22_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIVF22ICVF22
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF22ICVF22_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF22ICVF22_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIVF22ICVF22 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIVF22ICVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF22ICVF22 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF22ICVF22_swigregister(itkInPlaceImageFilterIVF22ICVF22)
class itkInPlaceImageFilterIVF22IVF22(itkImageToImageFilterAPython.itkImageToImageFilterIVF22IVF22):
    r"""Proxy of C++ itkInPlaceImageFilterIVF22IVF22 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF22IVF22_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF22IVF22_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF22IVF22_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF22IVF22_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF22IVF22_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIVF22IVF22
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF22IVF22_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF22IVF22_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIVF22IVF22 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIVF22IVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF22IVF22 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF22IVF22_swigregister(itkInPlaceImageFilterIVF22IVF22)
class itkInPlaceImageFilterIVF23ICVF23(itkImageToImageFilterAPython.itkImageToImageFilterIVF23ICVF23):
    r"""Proxy of C++ itkInPlaceImageFilterIVF23ICVF23 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF23ICVF23_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF23ICVF23_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF23ICVF23_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF23ICVF23_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF23ICVF23_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIVF23ICVF23
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF23ICVF23_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF23ICVF23_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIVF23ICVF23 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIVF23ICVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF23ICVF23 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF23ICVF23_swigregister(itkInPlaceImageFilterIVF23ICVF23)
class itkInPlaceImageFilterIVF23IVF23(itkImageToImageFilterAPython.itkImageToImageFilterIVF23IVF23):
    r"""Proxy of C++ itkInPlaceImageFilterIVF23IVF23 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF23IVF23_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF23IVF23_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF23IVF23_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF23IVF23_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF23IVF23_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIVF23IVF23
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF23IVF23_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF23IVF23_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIVF23IVF23 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIVF23IVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF23IVF23 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF23IVF23_swigregister(itkInPlaceImageFilterIVF23IVF23)
class itkInPlaceImageFilterIVF32ICVF32(itkImageToImageFilterAPython.itkImageToImageFilterIVF32ICVF32):
    r"""Proxy of C++ itkInPlaceImageFilterIVF32ICVF32 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF32ICVF32_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF32ICVF32_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF32ICVF32_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF32ICVF32_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF32ICVF32_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIVF32ICVF32
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF32ICVF32_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF32ICVF32_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIVF32ICVF32 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIVF32ICVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF32ICVF32 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF32ICVF32_swigregister(itkInPlaceImageFilterIVF32ICVF32)
class itkInPlaceImageFilterIVF32IVF32(itkImageToImageFilterAPython.itkImageToImageFilterIVF32IVF32):
    r"""Proxy of C++ itkInPlaceImageFilterIVF32IVF32 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF32IVF32_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF32IVF32_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF32IVF32_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF32IVF32_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF32IVF32_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIVF32IVF32
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF32IVF32_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF32IVF32_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIVF32IVF32 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIVF32IVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF32IVF32 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF32IVF32_swigregister(itkInPlaceImageFilterIVF32IVF32)
class itkInPlaceImageFilterIVF33ICVF33(itkImageToImageFilterAPython.itkImageToImageFilterIVF33ICVF33):
    r"""Proxy of C++ itkInPlaceImageFilterIVF33ICVF33 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF33ICVF33_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF33ICVF33_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF33ICVF33_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF33ICVF33_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF33ICVF33_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIVF33ICVF33
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF33ICVF33_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF33ICVF33_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIVF33ICVF33 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIVF33ICVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF33ICVF33 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF33ICVF33_swigregister(itkInPlaceImageFilterIVF33ICVF33)
class itkInPlaceImageFilterIVF33IVF33(itkImageToImageFilterAPython.itkImageToImageFilterIVF33IVF33):
    r"""Proxy of C++ itkInPlaceImageFilterIVF33IVF33 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF33IVF33_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF33IVF33_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF33IVF33_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF33IVF33_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF33IVF33_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIVF33IVF33
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF33IVF33_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF33IVF33_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIVF33IVF33 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIVF33IVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF33IVF33 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF33IVF33_swigregister(itkInPlaceImageFilterIVF33IVF33)
class itkInPlaceImageFilterIVF42ICVF42(itkImageToImageFilterAPython.itkImageToImageFilterIVF42ICVF42):
    r"""Proxy of C++ itkInPlaceImageFilterIVF42ICVF42 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF42ICVF42_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF42ICVF42_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF42ICVF42_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF42ICVF42_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF42ICVF42_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIVF42ICVF42
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF42ICVF42_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF42ICVF42_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIVF42ICVF42 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIVF42ICVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF42ICVF42 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF42ICVF42_swigregister(itkInPlaceImageFilterIVF42ICVF42)
class itkInPlaceImageFilterIVF42IVF42(itkImageToImageFilterAPython.itkImageToImageFilterIVF42IVF42):
    r"""Proxy of C++ itkInPlaceImageFilterIVF42IVF42 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF42IVF42_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF42IVF42_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF42IVF42_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF42IVF42_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF42IVF42_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIVF42IVF42
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF42IVF42_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF42IVF42_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIVF42IVF42 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIVF42IVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF42IVF42 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF42IVF42_swigregister(itkInPlaceImageFilterIVF42IVF42)
class itkInPlaceImageFilterIVF43ICVF43(itkImageToImageFilterAPython.itkImageToImageFilterIVF43ICVF43):
    r"""Proxy of C++ itkInPlaceImageFilterIVF43ICVF43 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF43ICVF43_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF43ICVF43_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF43ICVF43_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF43ICVF43_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF43ICVF43_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIVF43ICVF43
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF43ICVF43_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF43ICVF43_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIVF43ICVF43 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIVF43ICVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF43ICVF43 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF43ICVF43_swigregister(itkInPlaceImageFilterIVF43ICVF43)
class itkInPlaceImageFilterIVF43IVF43(itkImageToImageFilterAPython.itkImageToImageFilterIVF43IVF43):
    r"""Proxy of C++ itkInPlaceImageFilterIVF43IVF43 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    SetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF43IVF43_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF43IVF43_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF43IVF43_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF43IVF43_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF43IVF43_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterAPython.delete_itkInPlaceImageFilterIVF43IVF43
    cast = _swig_new_static_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF43IVF43_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF43IVF43_GetPointer)

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

        Create a new object of the class itkInPlaceImageFilterIVF43IVF43 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkInPlaceImageFilterIVF43IVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF43IVF43 in _itkInPlaceImageFilterAPython:
_itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF43IVF43_swigregister(itkInPlaceImageFilterIVF43IVF43)

