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

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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

def itkInPlaceImageFilterICF3ICF2_New():
  return itkInPlaceImageFilterICF3ICF2.New()


def itkInPlaceImageFilterIRGBUC3IRGBUC2_New():
  return itkInPlaceImageFilterIRGBUC3IRGBUC2.New()


def itkInPlaceImageFilterIF3IF2_New():
  return itkInPlaceImageFilterIF3IF2.New()


def itkInPlaceImageFilterIUC3IUC2_New():
  return itkInPlaceImageFilterIUC3IUC2.New()


def itkInPlaceImageFilterISS3ISS2_New():
  return itkInPlaceImageFilterISS3ISS2.New()


def itkInPlaceImageFilterICF2ICF3_New():
  return itkInPlaceImageFilterICF2ICF3.New()


def itkInPlaceImageFilterIRGBUC2IRGBUC3_New():
  return itkInPlaceImageFilterIRGBUC2IRGBUC3.New()


def itkInPlaceImageFilterIF2IF3_New():
  return itkInPlaceImageFilterIF2IF3.New()


def itkInPlaceImageFilterIUC2IUC3_New():
  return itkInPlaceImageFilterIUC2IUC3.New()


def itkInPlaceImageFilterISS2ISS3_New():
  return itkInPlaceImageFilterISS2ISS3.New()


def itkInPlaceImageFilterICF3IF3_New():
  return itkInPlaceImageFilterICF3IF3.New()


def itkInPlaceImageFilterICF2IF2_New():
  return itkInPlaceImageFilterICF2IF2.New()


def itkInPlaceImageFilterIF3ICF3_New():
  return itkInPlaceImageFilterIF3ICF3.New()


def itkInPlaceImageFilterIF2ICF2_New():
  return itkInPlaceImageFilterIF2ICF2.New()


def itkInPlaceImageFilterICF3ICF3_New():
  return itkInPlaceImageFilterICF3ICF3.New()


def itkInPlaceImageFilterICF2ICF2_New():
  return itkInPlaceImageFilterICF2ICF2.New()


def itkInPlaceImageFilterIF3ICVF43_New():
  return itkInPlaceImageFilterIF3ICVF43.New()


def itkInPlaceImageFilterIF2ICVF42_New():
  return itkInPlaceImageFilterIF2ICVF42.New()


def itkInPlaceImageFilterIF3ICVF33_New():
  return itkInPlaceImageFilterIF3ICVF33.New()


def itkInPlaceImageFilterIF2ICVF32_New():
  return itkInPlaceImageFilterIF2ICVF32.New()


def itkInPlaceImageFilterIF3ICVF23_New():
  return itkInPlaceImageFilterIF3ICVF23.New()


def itkInPlaceImageFilterIF2ICVF22_New():
  return itkInPlaceImageFilterIF2ICVF22.New()


def itkInPlaceImageFilterIF3IVF43_New():
  return itkInPlaceImageFilterIF3IVF43.New()


def itkInPlaceImageFilterIF2IVF42_New():
  return itkInPlaceImageFilterIF2IVF42.New()


def itkInPlaceImageFilterIF3IVF33_New():
  return itkInPlaceImageFilterIF3IVF33.New()


def itkInPlaceImageFilterIF2IVF32_New():
  return itkInPlaceImageFilterIF2IVF32.New()


def itkInPlaceImageFilterIF3IVF23_New():
  return itkInPlaceImageFilterIF3IVF23.New()


def itkInPlaceImageFilterIF2IVF22_New():
  return itkInPlaceImageFilterIF2IVF22.New()


def itkInPlaceImageFilterIUC3ICVF43_New():
  return itkInPlaceImageFilterIUC3ICVF43.New()


def itkInPlaceImageFilterIUC2ICVF42_New():
  return itkInPlaceImageFilterIUC2ICVF42.New()


def itkInPlaceImageFilterIUC3ICVF33_New():
  return itkInPlaceImageFilterIUC3ICVF33.New()


def itkInPlaceImageFilterIUC2ICVF32_New():
  return itkInPlaceImageFilterIUC2ICVF32.New()


def itkInPlaceImageFilterIUC3ICVF23_New():
  return itkInPlaceImageFilterIUC3ICVF23.New()


def itkInPlaceImageFilterIUC2ICVF22_New():
  return itkInPlaceImageFilterIUC2ICVF22.New()


def itkInPlaceImageFilterIUC3IVF43_New():
  return itkInPlaceImageFilterIUC3IVF43.New()


def itkInPlaceImageFilterIUC2IVF42_New():
  return itkInPlaceImageFilterIUC2IVF42.New()


def itkInPlaceImageFilterIUC3IVF33_New():
  return itkInPlaceImageFilterIUC3IVF33.New()


def itkInPlaceImageFilterIUC2IVF32_New():
  return itkInPlaceImageFilterIUC2IVF32.New()


def itkInPlaceImageFilterIUC3IVF23_New():
  return itkInPlaceImageFilterIUC3IVF23.New()


def itkInPlaceImageFilterIUC2IVF22_New():
  return itkInPlaceImageFilterIUC2IVF22.New()


def itkInPlaceImageFilterISS3ICVF43_New():
  return itkInPlaceImageFilterISS3ICVF43.New()


def itkInPlaceImageFilterISS2ICVF42_New():
  return itkInPlaceImageFilterISS2ICVF42.New()


def itkInPlaceImageFilterISS3ICVF33_New():
  return itkInPlaceImageFilterISS3ICVF33.New()


def itkInPlaceImageFilterISS2ICVF32_New():
  return itkInPlaceImageFilterISS2ICVF32.New()


def itkInPlaceImageFilterISS3ICVF23_New():
  return itkInPlaceImageFilterISS3ICVF23.New()


def itkInPlaceImageFilterISS2ICVF22_New():
  return itkInPlaceImageFilterISS2ICVF22.New()


def itkInPlaceImageFilterISS3IVF43_New():
  return itkInPlaceImageFilterISS3IVF43.New()


def itkInPlaceImageFilterISS2IVF42_New():
  return itkInPlaceImageFilterISS2IVF42.New()


def itkInPlaceImageFilterISS3IVF33_New():
  return itkInPlaceImageFilterISS3IVF33.New()


def itkInPlaceImageFilterISS2IVF32_New():
  return itkInPlaceImageFilterISS2IVF32.New()


def itkInPlaceImageFilterISS3IVF23_New():
  return itkInPlaceImageFilterISS3IVF23.New()


def itkInPlaceImageFilterISS2IVF22_New():
  return itkInPlaceImageFilterISS2IVF22.New()


def itkInPlaceImageFilterICVF43IF3_New():
  return itkInPlaceImageFilterICVF43IF3.New()


def itkInPlaceImageFilterICVF42IF2_New():
  return itkInPlaceImageFilterICVF42IF2.New()


def itkInPlaceImageFilterICVF33IF3_New():
  return itkInPlaceImageFilterICVF33IF3.New()


def itkInPlaceImageFilterICVF32IF2_New():
  return itkInPlaceImageFilterICVF32IF2.New()


def itkInPlaceImageFilterICVF23IF3_New():
  return itkInPlaceImageFilterICVF23IF3.New()


def itkInPlaceImageFilterICVF22IF2_New():
  return itkInPlaceImageFilterICVF22IF2.New()


def itkInPlaceImageFilterICVF43IUC3_New():
  return itkInPlaceImageFilterICVF43IUC3.New()


def itkInPlaceImageFilterICVF42IUC2_New():
  return itkInPlaceImageFilterICVF42IUC2.New()


def itkInPlaceImageFilterICVF33IUC3_New():
  return itkInPlaceImageFilterICVF33IUC3.New()


def itkInPlaceImageFilterICVF32IUC2_New():
  return itkInPlaceImageFilterICVF32IUC2.New()


def itkInPlaceImageFilterICVF23IUC3_New():
  return itkInPlaceImageFilterICVF23IUC3.New()


def itkInPlaceImageFilterICVF22IUC2_New():
  return itkInPlaceImageFilterICVF22IUC2.New()


def itkInPlaceImageFilterICVF43ISS3_New():
  return itkInPlaceImageFilterICVF43ISS3.New()


def itkInPlaceImageFilterICVF42ISS2_New():
  return itkInPlaceImageFilterICVF42ISS2.New()


def itkInPlaceImageFilterICVF33ISS3_New():
  return itkInPlaceImageFilterICVF33ISS3.New()


def itkInPlaceImageFilterICVF32ISS2_New():
  return itkInPlaceImageFilterICVF32ISS2.New()


def itkInPlaceImageFilterICVF23ISS3_New():
  return itkInPlaceImageFilterICVF23ISS3.New()


def itkInPlaceImageFilterICVF22ISS2_New():
  return itkInPlaceImageFilterICVF22ISS2.New()


def itkInPlaceImageFilterIVF43IF3_New():
  return itkInPlaceImageFilterIVF43IF3.New()


def itkInPlaceImageFilterIVF42IF2_New():
  return itkInPlaceImageFilterIVF42IF2.New()


def itkInPlaceImageFilterIVF33IF3_New():
  return itkInPlaceImageFilterIVF33IF3.New()


def itkInPlaceImageFilterIVF32IF2_New():
  return itkInPlaceImageFilterIVF32IF2.New()


def itkInPlaceImageFilterIVF23IF3_New():
  return itkInPlaceImageFilterIVF23IF3.New()


def itkInPlaceImageFilterIVF22IF2_New():
  return itkInPlaceImageFilterIVF22IF2.New()


def itkInPlaceImageFilterIVF43IUC3_New():
  return itkInPlaceImageFilterIVF43IUC3.New()


def itkInPlaceImageFilterIVF42IUC2_New():
  return itkInPlaceImageFilterIVF42IUC2.New()


def itkInPlaceImageFilterIVF33IUC3_New():
  return itkInPlaceImageFilterIVF33IUC3.New()


def itkInPlaceImageFilterIVF32IUC2_New():
  return itkInPlaceImageFilterIVF32IUC2.New()


def itkInPlaceImageFilterIVF23IUC3_New():
  return itkInPlaceImageFilterIVF23IUC3.New()


def itkInPlaceImageFilterIVF22IUC2_New():
  return itkInPlaceImageFilterIVF22IUC2.New()


def itkInPlaceImageFilterIVF43ISS3_New():
  return itkInPlaceImageFilterIVF43ISS3.New()


def itkInPlaceImageFilterIVF42ISS2_New():
  return itkInPlaceImageFilterIVF42ISS2.New()


def itkInPlaceImageFilterIVF33ISS3_New():
  return itkInPlaceImageFilterIVF33ISS3.New()


def itkInPlaceImageFilterIVF32ISS2_New():
  return itkInPlaceImageFilterIVF32ISS2.New()


def itkInPlaceImageFilterIVF23ISS3_New():
  return itkInPlaceImageFilterIVF23ISS3.New()


def itkInPlaceImageFilterIVF22ISS2_New():
  return itkInPlaceImageFilterIVF22ISS2.New()


def itkInPlaceImageFilterIF3VIF3_New():
  return itkInPlaceImageFilterIF3VIF3.New()


def itkInPlaceImageFilterVIF3IF3_New():
  return itkInPlaceImageFilterVIF3IF3.New()


def itkInPlaceImageFilterISS3VISS3_New():
  return itkInPlaceImageFilterISS3VISS3.New()


def itkInPlaceImageFilterVISS3ISS3_New():
  return itkInPlaceImageFilterVISS3ISS3.New()


def itkInPlaceImageFilterIUC3VIUC3_New():
  return itkInPlaceImageFilterIUC3VIUC3.New()


def itkInPlaceImageFilterVIUC3IUC3_New():
  return itkInPlaceImageFilterVIUC3IUC3.New()


def itkInPlaceImageFilterIF2VIF2_New():
  return itkInPlaceImageFilterIF2VIF2.New()


def itkInPlaceImageFilterVIF2IF2_New():
  return itkInPlaceImageFilterVIF2IF2.New()


def itkInPlaceImageFilterISS2VISS2_New():
  return itkInPlaceImageFilterISS2VISS2.New()


def itkInPlaceImageFilterVISS2ISS2_New():
  return itkInPlaceImageFilterVISS2ISS2.New()


def itkInPlaceImageFilterIUC2VIUC2_New():
  return itkInPlaceImageFilterIUC2VIUC2.New()


def itkInPlaceImageFilterVIUC2IUC2_New():
  return itkInPlaceImageFilterVIUC2IUC2.New()

class itkInPlaceImageFilterICF2ICF2(itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF2):
    r"""Proxy of C++ itkInPlaceImageFilterICF2ICF2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF2ICF2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF2ICF2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF2ICF2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF2ICF2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF2ICF2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterICF2ICF2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF2ICF2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF2ICF2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterICF2ICF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICF2ICF2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF2ICF2_swigregister(itkInPlaceImageFilterICF2ICF2)
class itkInPlaceImageFilterICF2ICF3(itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF3):
    r"""Proxy of C++ itkInPlaceImageFilterICF2ICF3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF2ICF3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF2ICF3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF2ICF3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF2ICF3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF2ICF3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterICF2ICF3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF2ICF3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF2ICF3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterICF2ICF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICF2ICF3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF2ICF3_swigregister(itkInPlaceImageFilterICF2ICF3)
class itkInPlaceImageFilterICF2IF2(itkImageToImageFilterBPython.itkImageToImageFilterICF2IF2):
    r"""Proxy of C++ itkInPlaceImageFilterICF2IF2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF2IF2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF2IF2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF2IF2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF2IF2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF2IF2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterICF2IF2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF2IF2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF2IF2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterICF2IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICF2IF2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF2IF2_swigregister(itkInPlaceImageFilterICF2IF2)
class itkInPlaceImageFilterICF3ICF2(itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF2):
    r"""Proxy of C++ itkInPlaceImageFilterICF3ICF2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3ICF2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3ICF2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3ICF2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3ICF2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3ICF2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterICF3ICF2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3ICF2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3ICF2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterICF3ICF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICF3ICF2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3ICF2_swigregister(itkInPlaceImageFilterICF3ICF2)
class itkInPlaceImageFilterICF3ICF3(itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF3):
    r"""Proxy of C++ itkInPlaceImageFilterICF3ICF3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3ICF3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3ICF3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3ICF3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3ICF3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3ICF3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterICF3ICF3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3ICF3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3ICF3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterICF3ICF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICF3ICF3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3ICF3_swigregister(itkInPlaceImageFilterICF3ICF3)
class itkInPlaceImageFilterICF3IF3(itkImageToImageFilterBPython.itkImageToImageFilterICF3IF3):
    r"""Proxy of C++ itkInPlaceImageFilterICF3IF3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3IF3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3IF3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3IF3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3IF3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3IF3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterICF3IF3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3IF3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3IF3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterICF3IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICF3IF3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3IF3_swigregister(itkInPlaceImageFilterICF3IF3)
class itkInPlaceImageFilterICVF22IF2(itkImageToImageFilterBPython.itkImageToImageFilterICVF22IF2):
    r"""Proxy of C++ itkInPlaceImageFilterICVF22IF2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF22IF2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF22IF2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF22IF2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF22IF2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF22IF2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterICVF22IF2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF22IF2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF22IF2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterICVF22IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF22IF2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF22IF2_swigregister(itkInPlaceImageFilterICVF22IF2)
class itkInPlaceImageFilterICVF22ISS2(itkImageToImageFilterBPython.itkImageToImageFilterICVF22ISS2):
    r"""Proxy of C++ itkInPlaceImageFilterICVF22ISS2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF22ISS2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF22ISS2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF22ISS2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF22ISS2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF22ISS2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterICVF22ISS2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF22ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF22ISS2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterICVF22ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF22ISS2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF22ISS2_swigregister(itkInPlaceImageFilterICVF22ISS2)
class itkInPlaceImageFilterICVF22IUC2(itkImageToImageFilterBPython.itkImageToImageFilterICVF22IUC2):
    r"""Proxy of C++ itkInPlaceImageFilterICVF22IUC2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF22IUC2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF22IUC2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF22IUC2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF22IUC2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF22IUC2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterICVF22IUC2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF22IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF22IUC2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterICVF22IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF22IUC2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF22IUC2_swigregister(itkInPlaceImageFilterICVF22IUC2)
class itkInPlaceImageFilterICVF23IF3(itkImageToImageFilterBPython.itkImageToImageFilterICVF23IF3):
    r"""Proxy of C++ itkInPlaceImageFilterICVF23IF3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF23IF3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF23IF3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF23IF3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF23IF3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF23IF3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterICVF23IF3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF23IF3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF23IF3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterICVF23IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF23IF3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF23IF3_swigregister(itkInPlaceImageFilterICVF23IF3)
class itkInPlaceImageFilterICVF23ISS3(itkImageToImageFilterBPython.itkImageToImageFilterICVF23ISS3):
    r"""Proxy of C++ itkInPlaceImageFilterICVF23ISS3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF23ISS3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF23ISS3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF23ISS3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF23ISS3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF23ISS3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterICVF23ISS3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF23ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF23ISS3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterICVF23ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF23ISS3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF23ISS3_swigregister(itkInPlaceImageFilterICVF23ISS3)
class itkInPlaceImageFilterICVF23IUC3(itkImageToImageFilterBPython.itkImageToImageFilterICVF23IUC3):
    r"""Proxy of C++ itkInPlaceImageFilterICVF23IUC3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF23IUC3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF23IUC3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF23IUC3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF23IUC3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF23IUC3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterICVF23IUC3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF23IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF23IUC3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterICVF23IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF23IUC3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF23IUC3_swigregister(itkInPlaceImageFilterICVF23IUC3)
class itkInPlaceImageFilterICVF32IF2(itkImageToImageFilterBPython.itkImageToImageFilterICVF32IF2):
    r"""Proxy of C++ itkInPlaceImageFilterICVF32IF2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF32IF2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF32IF2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF32IF2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF32IF2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF32IF2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterICVF32IF2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF32IF2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF32IF2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterICVF32IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF32IF2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF32IF2_swigregister(itkInPlaceImageFilterICVF32IF2)
class itkInPlaceImageFilterICVF32ISS2(itkImageToImageFilterBPython.itkImageToImageFilterICVF32ISS2):
    r"""Proxy of C++ itkInPlaceImageFilterICVF32ISS2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF32ISS2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF32ISS2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF32ISS2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF32ISS2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF32ISS2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterICVF32ISS2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF32ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF32ISS2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterICVF32ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF32ISS2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF32ISS2_swigregister(itkInPlaceImageFilterICVF32ISS2)
class itkInPlaceImageFilterICVF32IUC2(itkImageToImageFilterBPython.itkImageToImageFilterICVF32IUC2):
    r"""Proxy of C++ itkInPlaceImageFilterICVF32IUC2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF32IUC2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF32IUC2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF32IUC2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF32IUC2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF32IUC2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterICVF32IUC2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF32IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF32IUC2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterICVF32IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF32IUC2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF32IUC2_swigregister(itkInPlaceImageFilterICVF32IUC2)
class itkInPlaceImageFilterICVF33IF3(itkImageToImageFilterBPython.itkImageToImageFilterICVF33IF3):
    r"""Proxy of C++ itkInPlaceImageFilterICVF33IF3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF33IF3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF33IF3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF33IF3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF33IF3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF33IF3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterICVF33IF3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF33IF3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF33IF3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterICVF33IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF33IF3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF33IF3_swigregister(itkInPlaceImageFilterICVF33IF3)
class itkInPlaceImageFilterICVF33ISS3(itkImageToImageFilterBPython.itkImageToImageFilterICVF33ISS3):
    r"""Proxy of C++ itkInPlaceImageFilterICVF33ISS3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF33ISS3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF33ISS3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF33ISS3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF33ISS3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF33ISS3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterICVF33ISS3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF33ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF33ISS3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterICVF33ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF33ISS3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF33ISS3_swigregister(itkInPlaceImageFilterICVF33ISS3)
class itkInPlaceImageFilterICVF33IUC3(itkImageToImageFilterBPython.itkImageToImageFilterICVF33IUC3):
    r"""Proxy of C++ itkInPlaceImageFilterICVF33IUC3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF33IUC3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF33IUC3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF33IUC3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF33IUC3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF33IUC3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterICVF33IUC3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF33IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF33IUC3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterICVF33IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF33IUC3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF33IUC3_swigregister(itkInPlaceImageFilterICVF33IUC3)
class itkInPlaceImageFilterICVF42IF2(itkImageToImageFilterBPython.itkImageToImageFilterICVF42IF2):
    r"""Proxy of C++ itkInPlaceImageFilterICVF42IF2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF42IF2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF42IF2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF42IF2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF42IF2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF42IF2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterICVF42IF2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF42IF2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF42IF2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterICVF42IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF42IF2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF42IF2_swigregister(itkInPlaceImageFilterICVF42IF2)
class itkInPlaceImageFilterICVF42ISS2(itkImageToImageFilterBPython.itkImageToImageFilterICVF42ISS2):
    r"""Proxy of C++ itkInPlaceImageFilterICVF42ISS2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF42ISS2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF42ISS2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF42ISS2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF42ISS2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF42ISS2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterICVF42ISS2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF42ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF42ISS2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterICVF42ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF42ISS2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF42ISS2_swigregister(itkInPlaceImageFilterICVF42ISS2)
class itkInPlaceImageFilterICVF42IUC2(itkImageToImageFilterBPython.itkImageToImageFilterICVF42IUC2):
    r"""Proxy of C++ itkInPlaceImageFilterICVF42IUC2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF42IUC2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF42IUC2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF42IUC2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF42IUC2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF42IUC2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterICVF42IUC2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF42IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF42IUC2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterICVF42IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF42IUC2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF42IUC2_swigregister(itkInPlaceImageFilterICVF42IUC2)
class itkInPlaceImageFilterICVF43IF3(itkImageToImageFilterBPython.itkImageToImageFilterICVF43IF3):
    r"""Proxy of C++ itkInPlaceImageFilterICVF43IF3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF43IF3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF43IF3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF43IF3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF43IF3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF43IF3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterICVF43IF3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF43IF3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF43IF3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterICVF43IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF43IF3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF43IF3_swigregister(itkInPlaceImageFilterICVF43IF3)
class itkInPlaceImageFilterICVF43ISS3(itkImageToImageFilterBPython.itkImageToImageFilterICVF43ISS3):
    r"""Proxy of C++ itkInPlaceImageFilterICVF43ISS3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF43ISS3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF43ISS3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF43ISS3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF43ISS3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF43ISS3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterICVF43ISS3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF43ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF43ISS3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterICVF43ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF43ISS3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF43ISS3_swigregister(itkInPlaceImageFilterICVF43ISS3)
class itkInPlaceImageFilterICVF43IUC3(itkImageToImageFilterBPython.itkImageToImageFilterICVF43IUC3):
    r"""Proxy of C++ itkInPlaceImageFilterICVF43IUC3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF43IUC3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF43IUC3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF43IUC3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF43IUC3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF43IUC3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterICVF43IUC3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF43IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF43IUC3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterICVF43IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterICVF43IUC3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF43IUC3_swigregister(itkInPlaceImageFilterICVF43IUC3)
class itkInPlaceImageFilterIF2ICF2(itkImageToImageFilterBPython.itkImageToImageFilterIF2ICF2):
    r"""Proxy of C++ itkInPlaceImageFilterIF2ICF2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICF2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICF2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICF2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICF2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICF2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIF2ICF2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICF2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICF2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIF2ICF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF2ICF2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICF2_swigregister(itkInPlaceImageFilterIF2ICF2)
class itkInPlaceImageFilterIF2ICVF22(itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF22):
    r"""Proxy of C++ itkInPlaceImageFilterIF2ICVF22 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICVF22_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICVF22_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICVF22_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICVF22_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICVF22_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIF2ICVF22
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICVF22_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICVF22_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIF2ICVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF2ICVF22 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICVF22_swigregister(itkInPlaceImageFilterIF2ICVF22)
class itkInPlaceImageFilterIF2ICVF32(itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF32):
    r"""Proxy of C++ itkInPlaceImageFilterIF2ICVF32 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICVF32_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICVF32_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICVF32_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICVF32_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICVF32_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIF2ICVF32
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICVF32_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICVF32_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIF2ICVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF2ICVF32 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICVF32_swigregister(itkInPlaceImageFilterIF2ICVF32)
class itkInPlaceImageFilterIF2ICVF42(itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF42):
    r"""Proxy of C++ itkInPlaceImageFilterIF2ICVF42 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICVF42_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICVF42_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICVF42_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICVF42_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICVF42_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIF2ICVF42
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICVF42_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICVF42_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIF2ICVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF2ICVF42 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2ICVF42_swigregister(itkInPlaceImageFilterIF2ICVF42)
class itkInPlaceImageFilterIF2IF3(itkImageToImageFilterBPython.itkImageToImageFilterIF2IF3):
    r"""Proxy of C++ itkInPlaceImageFilterIF2IF3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IF3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IF3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IF3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IF3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IF3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIF2IF3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IF3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IF3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIF2IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF2IF3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IF3_swigregister(itkInPlaceImageFilterIF2IF3)
class itkInPlaceImageFilterIF2IVF22(itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF22):
    r"""Proxy of C++ itkInPlaceImageFilterIF2IVF22 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IVF22_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IVF22_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IVF22_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IVF22_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IVF22_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIF2IVF22
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IVF22_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IVF22_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIF2IVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF2IVF22 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IVF22_swigregister(itkInPlaceImageFilterIF2IVF22)
class itkInPlaceImageFilterIF2IVF32(itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF32):
    r"""Proxy of C++ itkInPlaceImageFilterIF2IVF32 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IVF32_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IVF32_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IVF32_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IVF32_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IVF32_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIF2IVF32
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IVF32_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IVF32_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIF2IVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF2IVF32 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IVF32_swigregister(itkInPlaceImageFilterIF2IVF32)
class itkInPlaceImageFilterIF2IVF42(itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF42):
    r"""Proxy of C++ itkInPlaceImageFilterIF2IVF42 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IVF42_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IVF42_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IVF42_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IVF42_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IVF42_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIF2IVF42
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IVF42_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IVF42_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIF2IVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF2IVF42 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2IVF42_swigregister(itkInPlaceImageFilterIF2IVF42)
class itkInPlaceImageFilterIF2VIF2(itkImageToImageFilterBPython.itkImageToImageFilterIF2VIF2):
    r"""Proxy of C++ itkInPlaceImageFilterIF2VIF2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2VIF2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2VIF2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2VIF2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2VIF2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2VIF2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIF2VIF2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2VIF2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2VIF2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIF2VIF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF2VIF2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF2VIF2_swigregister(itkInPlaceImageFilterIF2VIF2)
class itkInPlaceImageFilterIF3ICF3(itkImageToImageFilterBPython.itkImageToImageFilterIF3ICF3):
    r"""Proxy of C++ itkInPlaceImageFilterIF3ICF3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICF3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICF3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICF3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICF3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICF3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIF3ICF3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICF3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICF3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIF3ICF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF3ICF3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICF3_swigregister(itkInPlaceImageFilterIF3ICF3)
class itkInPlaceImageFilterIF3ICVF23(itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF23):
    r"""Proxy of C++ itkInPlaceImageFilterIF3ICVF23 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICVF23_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICVF23_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICVF23_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICVF23_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICVF23_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIF3ICVF23
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICVF23_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICVF23_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIF3ICVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF3ICVF23 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICVF23_swigregister(itkInPlaceImageFilterIF3ICVF23)
class itkInPlaceImageFilterIF3ICVF33(itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF33):
    r"""Proxy of C++ itkInPlaceImageFilterIF3ICVF33 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICVF33_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICVF33_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICVF33_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICVF33_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICVF33_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIF3ICVF33
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICVF33_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICVF33_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIF3ICVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF3ICVF33 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICVF33_swigregister(itkInPlaceImageFilterIF3ICVF33)
class itkInPlaceImageFilterIF3ICVF43(itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF43):
    r"""Proxy of C++ itkInPlaceImageFilterIF3ICVF43 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICVF43_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICVF43_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICVF43_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICVF43_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICVF43_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIF3ICVF43
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICVF43_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICVF43_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIF3ICVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF3ICVF43 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3ICVF43_swigregister(itkInPlaceImageFilterIF3ICVF43)
class itkInPlaceImageFilterIF3IF2(itkImageToImageFilterBPython.itkImageToImageFilterIF3IF2):
    r"""Proxy of C++ itkInPlaceImageFilterIF3IF2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IF2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IF2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IF2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IF2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IF2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIF3IF2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IF2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IF2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIF3IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF3IF2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IF2_swigregister(itkInPlaceImageFilterIF3IF2)
class itkInPlaceImageFilterIF3IVF23(itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF23):
    r"""Proxy of C++ itkInPlaceImageFilterIF3IVF23 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IVF23_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IVF23_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IVF23_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IVF23_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IVF23_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIF3IVF23
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IVF23_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IVF23_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIF3IVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF3IVF23 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IVF23_swigregister(itkInPlaceImageFilterIF3IVF23)
class itkInPlaceImageFilterIF3IVF33(itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF33):
    r"""Proxy of C++ itkInPlaceImageFilterIF3IVF33 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IVF33_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IVF33_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IVF33_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IVF33_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IVF33_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIF3IVF33
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IVF33_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IVF33_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIF3IVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF3IVF33 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IVF33_swigregister(itkInPlaceImageFilterIF3IVF33)
class itkInPlaceImageFilterIF3IVF43(itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF43):
    r"""Proxy of C++ itkInPlaceImageFilterIF3IVF43 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IVF43_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IVF43_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IVF43_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IVF43_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IVF43_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIF3IVF43
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IVF43_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IVF43_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIF3IVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF3IVF43 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3IVF43_swigregister(itkInPlaceImageFilterIF3IVF43)
class itkInPlaceImageFilterIF3VIF3(itkImageToImageFilterBPython.itkImageToImageFilterIF3VIF3):
    r"""Proxy of C++ itkInPlaceImageFilterIF3VIF3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3VIF3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3VIF3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3VIF3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3VIF3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3VIF3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIF3VIF3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3VIF3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3VIF3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIF3VIF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIF3VIF3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIF3VIF3_swigregister(itkInPlaceImageFilterIF3VIF3)
class itkInPlaceImageFilterIRGBUC2IRGBUC3(itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IRGBUC3):
    r"""Proxy of C++ itkInPlaceImageFilterIRGBUC2IRGBUC3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIRGBUC2IRGBUC3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIRGBUC2IRGBUC3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIRGBUC2IRGBUC3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIRGBUC2IRGBUC3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIRGBUC2IRGBUC3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIRGBUC2IRGBUC3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIRGBUC2IRGBUC3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIRGBUC2IRGBUC3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIRGBUC2IRGBUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIRGBUC2IRGBUC3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIRGBUC2IRGBUC3_swigregister(itkInPlaceImageFilterIRGBUC2IRGBUC3)
class itkInPlaceImageFilterIRGBUC3IRGBUC2(itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IRGBUC2):
    r"""Proxy of C++ itkInPlaceImageFilterIRGBUC3IRGBUC2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIRGBUC3IRGBUC2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIRGBUC3IRGBUC2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIRGBUC3IRGBUC2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIRGBUC3IRGBUC2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIRGBUC3IRGBUC2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIRGBUC3IRGBUC2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIRGBUC3IRGBUC2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIRGBUC3IRGBUC2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIRGBUC3IRGBUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIRGBUC3IRGBUC2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIRGBUC3IRGBUC2_swigregister(itkInPlaceImageFilterIRGBUC3IRGBUC2)
class itkInPlaceImageFilterISS2ICVF22(itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF22):
    r"""Proxy of C++ itkInPlaceImageFilterISS2ICVF22 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ICVF22_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ICVF22_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ICVF22_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ICVF22_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ICVF22_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterISS2ICVF22
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ICVF22_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ICVF22_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterISS2ICVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterISS2ICVF22 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ICVF22_swigregister(itkInPlaceImageFilterISS2ICVF22)
class itkInPlaceImageFilterISS2ICVF32(itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF32):
    r"""Proxy of C++ itkInPlaceImageFilterISS2ICVF32 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ICVF32_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ICVF32_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ICVF32_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ICVF32_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ICVF32_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterISS2ICVF32
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ICVF32_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ICVF32_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterISS2ICVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterISS2ICVF32 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ICVF32_swigregister(itkInPlaceImageFilterISS2ICVF32)
class itkInPlaceImageFilterISS2ICVF42(itkImageToImageFilterBPython.itkImageToImageFilterISS2ICVF42):
    r"""Proxy of C++ itkInPlaceImageFilterISS2ICVF42 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ICVF42_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ICVF42_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ICVF42_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ICVF42_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ICVF42_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterISS2ICVF42
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ICVF42_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ICVF42_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterISS2ICVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterISS2ICVF42 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ICVF42_swigregister(itkInPlaceImageFilterISS2ICVF42)
class itkInPlaceImageFilterISS2ISS3(itkImageToImageFilterBPython.itkImageToImageFilterISS2ISS3):
    r"""Proxy of C++ itkInPlaceImageFilterISS2ISS3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ISS3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ISS3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ISS3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ISS3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ISS3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterISS2ISS3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ISS3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterISS2ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterISS2ISS3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2ISS3_swigregister(itkInPlaceImageFilterISS2ISS3)
class itkInPlaceImageFilterISS2IVF22(itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF22):
    r"""Proxy of C++ itkInPlaceImageFilterISS2IVF22 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2IVF22_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2IVF22_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2IVF22_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2IVF22_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2IVF22_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterISS2IVF22
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2IVF22_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2IVF22_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterISS2IVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterISS2IVF22 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2IVF22_swigregister(itkInPlaceImageFilterISS2IVF22)
class itkInPlaceImageFilterISS2IVF32(itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF32):
    r"""Proxy of C++ itkInPlaceImageFilterISS2IVF32 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2IVF32_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2IVF32_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2IVF32_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2IVF32_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2IVF32_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterISS2IVF32
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2IVF32_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2IVF32_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterISS2IVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterISS2IVF32 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2IVF32_swigregister(itkInPlaceImageFilterISS2IVF32)
class itkInPlaceImageFilterISS2IVF42(itkImageToImageFilterBPython.itkImageToImageFilterISS2IVF42):
    r"""Proxy of C++ itkInPlaceImageFilterISS2IVF42 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2IVF42_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2IVF42_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2IVF42_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2IVF42_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2IVF42_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterISS2IVF42
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2IVF42_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2IVF42_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterISS2IVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterISS2IVF42 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2IVF42_swigregister(itkInPlaceImageFilterISS2IVF42)
class itkInPlaceImageFilterISS2VISS2(itkImageToImageFilterBPython.itkImageToImageFilterISS2VISS2):
    r"""Proxy of C++ itkInPlaceImageFilterISS2VISS2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2VISS2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2VISS2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2VISS2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2VISS2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2VISS2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterISS2VISS2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2VISS2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2VISS2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterISS2VISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterISS2VISS2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS2VISS2_swigregister(itkInPlaceImageFilterISS2VISS2)
class itkInPlaceImageFilterISS3ICVF23(itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF23):
    r"""Proxy of C++ itkInPlaceImageFilterISS3ICVF23 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ICVF23_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ICVF23_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ICVF23_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ICVF23_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ICVF23_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterISS3ICVF23
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ICVF23_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ICVF23_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterISS3ICVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterISS3ICVF23 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ICVF23_swigregister(itkInPlaceImageFilterISS3ICVF23)
class itkInPlaceImageFilterISS3ICVF33(itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF33):
    r"""Proxy of C++ itkInPlaceImageFilterISS3ICVF33 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ICVF33_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ICVF33_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ICVF33_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ICVF33_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ICVF33_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterISS3ICVF33
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ICVF33_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ICVF33_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterISS3ICVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterISS3ICVF33 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ICVF33_swigregister(itkInPlaceImageFilterISS3ICVF33)
class itkInPlaceImageFilterISS3ICVF43(itkImageToImageFilterBPython.itkImageToImageFilterISS3ICVF43):
    r"""Proxy of C++ itkInPlaceImageFilterISS3ICVF43 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ICVF43_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ICVF43_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ICVF43_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ICVF43_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ICVF43_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterISS3ICVF43
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ICVF43_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ICVF43_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterISS3ICVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterISS3ICVF43 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ICVF43_swigregister(itkInPlaceImageFilterISS3ICVF43)
class itkInPlaceImageFilterISS3ISS2(itkImageToImageFilterBPython.itkImageToImageFilterISS3ISS2):
    r"""Proxy of C++ itkInPlaceImageFilterISS3ISS2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ISS2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ISS2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ISS2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ISS2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ISS2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterISS3ISS2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ISS2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterISS3ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterISS3ISS2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3ISS2_swigregister(itkInPlaceImageFilterISS3ISS2)
class itkInPlaceImageFilterISS3IVF23(itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF23):
    r"""Proxy of C++ itkInPlaceImageFilterISS3IVF23 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3IVF23_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3IVF23_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3IVF23_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3IVF23_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3IVF23_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterISS3IVF23
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3IVF23_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3IVF23_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterISS3IVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterISS3IVF23 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3IVF23_swigregister(itkInPlaceImageFilterISS3IVF23)
class itkInPlaceImageFilterISS3IVF33(itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF33):
    r"""Proxy of C++ itkInPlaceImageFilterISS3IVF33 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3IVF33_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3IVF33_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3IVF33_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3IVF33_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3IVF33_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterISS3IVF33
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3IVF33_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3IVF33_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterISS3IVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterISS3IVF33 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3IVF33_swigregister(itkInPlaceImageFilterISS3IVF33)
class itkInPlaceImageFilterISS3IVF43(itkImageToImageFilterBPython.itkImageToImageFilterISS3IVF43):
    r"""Proxy of C++ itkInPlaceImageFilterISS3IVF43 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3IVF43_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3IVF43_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3IVF43_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3IVF43_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3IVF43_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterISS3IVF43
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3IVF43_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3IVF43_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterISS3IVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterISS3IVF43 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3IVF43_swigregister(itkInPlaceImageFilterISS3IVF43)
class itkInPlaceImageFilterISS3VISS3(itkImageToImageFilterBPython.itkImageToImageFilterISS3VISS3):
    r"""Proxy of C++ itkInPlaceImageFilterISS3VISS3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3VISS3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3VISS3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3VISS3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3VISS3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3VISS3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterISS3VISS3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3VISS3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3VISS3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterISS3VISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterISS3VISS3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterISS3VISS3_swigregister(itkInPlaceImageFilterISS3VISS3)
class itkInPlaceImageFilterIUC2ICVF22(itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF22):
    r"""Proxy of C++ itkInPlaceImageFilterIUC2ICVF22 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2ICVF22_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2ICVF22_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2ICVF22_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2ICVF22_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2ICVF22_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIUC2ICVF22
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2ICVF22_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2ICVF22_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIUC2ICVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUC2ICVF22 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2ICVF22_swigregister(itkInPlaceImageFilterIUC2ICVF22)
class itkInPlaceImageFilterIUC2ICVF32(itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF32):
    r"""Proxy of C++ itkInPlaceImageFilterIUC2ICVF32 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2ICVF32_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2ICVF32_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2ICVF32_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2ICVF32_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2ICVF32_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIUC2ICVF32
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2ICVF32_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2ICVF32_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIUC2ICVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUC2ICVF32 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2ICVF32_swigregister(itkInPlaceImageFilterIUC2ICVF32)
class itkInPlaceImageFilterIUC2ICVF42(itkImageToImageFilterBPython.itkImageToImageFilterIUC2ICVF42):
    r"""Proxy of C++ itkInPlaceImageFilterIUC2ICVF42 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2ICVF42_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2ICVF42_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2ICVF42_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2ICVF42_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2ICVF42_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIUC2ICVF42
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2ICVF42_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2ICVF42_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIUC2ICVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUC2ICVF42 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2ICVF42_swigregister(itkInPlaceImageFilterIUC2ICVF42)
class itkInPlaceImageFilterIUC2IUC3(itkImageToImageFilterBPython.itkImageToImageFilterIUC2IUC3):
    r"""Proxy of C++ itkInPlaceImageFilterIUC2IUC3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IUC3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IUC3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IUC3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IUC3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IUC3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIUC2IUC3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IUC3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIUC2IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUC2IUC3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IUC3_swigregister(itkInPlaceImageFilterIUC2IUC3)
class itkInPlaceImageFilterIUC2IVF22(itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF22):
    r"""Proxy of C++ itkInPlaceImageFilterIUC2IVF22 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IVF22_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IVF22_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IVF22_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IVF22_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IVF22_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIUC2IVF22
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IVF22_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IVF22_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIUC2IVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUC2IVF22 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IVF22_swigregister(itkInPlaceImageFilterIUC2IVF22)
class itkInPlaceImageFilterIUC2IVF32(itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF32):
    r"""Proxy of C++ itkInPlaceImageFilterIUC2IVF32 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IVF32_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IVF32_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IVF32_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IVF32_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IVF32_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIUC2IVF32
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IVF32_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IVF32_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIUC2IVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUC2IVF32 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IVF32_swigregister(itkInPlaceImageFilterIUC2IVF32)
class itkInPlaceImageFilterIUC2IVF42(itkImageToImageFilterBPython.itkImageToImageFilterIUC2IVF42):
    r"""Proxy of C++ itkInPlaceImageFilterIUC2IVF42 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IVF42_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IVF42_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IVF42_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IVF42_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IVF42_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIUC2IVF42
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IVF42_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IVF42_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIUC2IVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUC2IVF42 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2IVF42_swigregister(itkInPlaceImageFilterIUC2IVF42)
class itkInPlaceImageFilterIUC2VIUC2(itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIUC2):
    r"""Proxy of C++ itkInPlaceImageFilterIUC2VIUC2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2VIUC2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2VIUC2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2VIUC2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2VIUC2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2VIUC2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIUC2VIUC2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2VIUC2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2VIUC2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIUC2VIUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUC2VIUC2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC2VIUC2_swigregister(itkInPlaceImageFilterIUC2VIUC2)
class itkInPlaceImageFilterIUC3ICVF23(itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF23):
    r"""Proxy of C++ itkInPlaceImageFilterIUC3ICVF23 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3ICVF23_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3ICVF23_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3ICVF23_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3ICVF23_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3ICVF23_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIUC3ICVF23
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3ICVF23_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3ICVF23_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIUC3ICVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUC3ICVF23 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3ICVF23_swigregister(itkInPlaceImageFilterIUC3ICVF23)
class itkInPlaceImageFilterIUC3ICVF33(itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF33):
    r"""Proxy of C++ itkInPlaceImageFilterIUC3ICVF33 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3ICVF33_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3ICVF33_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3ICVF33_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3ICVF33_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3ICVF33_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIUC3ICVF33
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3ICVF33_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3ICVF33_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIUC3ICVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUC3ICVF33 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3ICVF33_swigregister(itkInPlaceImageFilterIUC3ICVF33)
class itkInPlaceImageFilterIUC3ICVF43(itkImageToImageFilterBPython.itkImageToImageFilterIUC3ICVF43):
    r"""Proxy of C++ itkInPlaceImageFilterIUC3ICVF43 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3ICVF43_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3ICVF43_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3ICVF43_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3ICVF43_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3ICVF43_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIUC3ICVF43
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3ICVF43_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3ICVF43_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIUC3ICVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUC3ICVF43 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3ICVF43_swigregister(itkInPlaceImageFilterIUC3ICVF43)
class itkInPlaceImageFilterIUC3IUC2(itkImageToImageFilterBPython.itkImageToImageFilterIUC3IUC2):
    r"""Proxy of C++ itkInPlaceImageFilterIUC3IUC2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IUC2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IUC2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IUC2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IUC2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IUC2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIUC3IUC2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IUC2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIUC3IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUC3IUC2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IUC2_swigregister(itkInPlaceImageFilterIUC3IUC2)
class itkInPlaceImageFilterIUC3IVF23(itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF23):
    r"""Proxy of C++ itkInPlaceImageFilterIUC3IVF23 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IVF23_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IVF23_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IVF23_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IVF23_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IVF23_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIUC3IVF23
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IVF23_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IVF23_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIUC3IVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUC3IVF23 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IVF23_swigregister(itkInPlaceImageFilterIUC3IVF23)
class itkInPlaceImageFilterIUC3IVF33(itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF33):
    r"""Proxy of C++ itkInPlaceImageFilterIUC3IVF33 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IVF33_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IVF33_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IVF33_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IVF33_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IVF33_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIUC3IVF33
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IVF33_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IVF33_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIUC3IVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUC3IVF33 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IVF33_swigregister(itkInPlaceImageFilterIUC3IVF33)
class itkInPlaceImageFilterIUC3IVF43(itkImageToImageFilterBPython.itkImageToImageFilterIUC3IVF43):
    r"""Proxy of C++ itkInPlaceImageFilterIUC3IVF43 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IVF43_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IVF43_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IVF43_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IVF43_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IVF43_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIUC3IVF43
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IVF43_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IVF43_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIUC3IVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUC3IVF43 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3IVF43_swigregister(itkInPlaceImageFilterIUC3IVF43)
class itkInPlaceImageFilterIUC3VIUC3(itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIUC3):
    r"""Proxy of C++ itkInPlaceImageFilterIUC3VIUC3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3VIUC3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3VIUC3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3VIUC3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3VIUC3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3VIUC3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIUC3VIUC3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3VIUC3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3VIUC3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIUC3VIUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIUC3VIUC3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIUC3VIUC3_swigregister(itkInPlaceImageFilterIUC3VIUC3)
class itkInPlaceImageFilterIVF22IF2(itkImageToImageFilterBPython.itkImageToImageFilterIVF22IF2):
    r"""Proxy of C++ itkInPlaceImageFilterIVF22IF2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF22IF2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF22IF2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF22IF2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF22IF2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF22IF2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIVF22IF2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF22IF2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF22IF2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIVF22IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF22IF2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF22IF2_swigregister(itkInPlaceImageFilterIVF22IF2)
class itkInPlaceImageFilterIVF22ISS2(itkImageToImageFilterBPython.itkImageToImageFilterIVF22ISS2):
    r"""Proxy of C++ itkInPlaceImageFilterIVF22ISS2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF22ISS2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF22ISS2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF22ISS2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF22ISS2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF22ISS2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIVF22ISS2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF22ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF22ISS2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIVF22ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF22ISS2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF22ISS2_swigregister(itkInPlaceImageFilterIVF22ISS2)
class itkInPlaceImageFilterIVF22IUC2(itkImageToImageFilterBPython.itkImageToImageFilterIVF22IUC2):
    r"""Proxy of C++ itkInPlaceImageFilterIVF22IUC2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF22IUC2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF22IUC2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF22IUC2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF22IUC2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF22IUC2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIVF22IUC2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF22IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF22IUC2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIVF22IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF22IUC2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF22IUC2_swigregister(itkInPlaceImageFilterIVF22IUC2)
class itkInPlaceImageFilterIVF23IF3(itkImageToImageFilterBPython.itkImageToImageFilterIVF23IF3):
    r"""Proxy of C++ itkInPlaceImageFilterIVF23IF3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF23IF3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF23IF3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF23IF3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF23IF3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF23IF3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIVF23IF3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF23IF3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF23IF3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIVF23IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF23IF3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF23IF3_swigregister(itkInPlaceImageFilterIVF23IF3)
class itkInPlaceImageFilterIVF23ISS3(itkImageToImageFilterBPython.itkImageToImageFilterIVF23ISS3):
    r"""Proxy of C++ itkInPlaceImageFilterIVF23ISS3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF23ISS3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF23ISS3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF23ISS3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF23ISS3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF23ISS3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIVF23ISS3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF23ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF23ISS3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIVF23ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF23ISS3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF23ISS3_swigregister(itkInPlaceImageFilterIVF23ISS3)
class itkInPlaceImageFilterIVF23IUC3(itkImageToImageFilterBPython.itkImageToImageFilterIVF23IUC3):
    r"""Proxy of C++ itkInPlaceImageFilterIVF23IUC3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF23IUC3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF23IUC3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF23IUC3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF23IUC3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF23IUC3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIVF23IUC3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF23IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF23IUC3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIVF23IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF23IUC3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF23IUC3_swigregister(itkInPlaceImageFilterIVF23IUC3)
class itkInPlaceImageFilterIVF32IF2(itkImageToImageFilterBPython.itkImageToImageFilterIVF32IF2):
    r"""Proxy of C++ itkInPlaceImageFilterIVF32IF2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF32IF2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF32IF2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF32IF2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF32IF2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF32IF2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIVF32IF2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF32IF2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF32IF2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIVF32IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF32IF2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF32IF2_swigregister(itkInPlaceImageFilterIVF32IF2)
class itkInPlaceImageFilterIVF32ISS2(itkImageToImageFilterBPython.itkImageToImageFilterIVF32ISS2):
    r"""Proxy of C++ itkInPlaceImageFilterIVF32ISS2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF32ISS2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF32ISS2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF32ISS2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF32ISS2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF32ISS2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIVF32ISS2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF32ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF32ISS2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIVF32ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF32ISS2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF32ISS2_swigregister(itkInPlaceImageFilterIVF32ISS2)
class itkInPlaceImageFilterIVF32IUC2(itkImageToImageFilterBPython.itkImageToImageFilterIVF32IUC2):
    r"""Proxy of C++ itkInPlaceImageFilterIVF32IUC2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF32IUC2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF32IUC2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF32IUC2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF32IUC2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF32IUC2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIVF32IUC2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF32IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF32IUC2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIVF32IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF32IUC2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF32IUC2_swigregister(itkInPlaceImageFilterIVF32IUC2)
class itkInPlaceImageFilterIVF33IF3(itkImageToImageFilterBPython.itkImageToImageFilterIVF33IF3):
    r"""Proxy of C++ itkInPlaceImageFilterIVF33IF3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF33IF3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF33IF3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF33IF3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF33IF3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF33IF3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIVF33IF3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF33IF3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF33IF3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIVF33IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF33IF3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF33IF3_swigregister(itkInPlaceImageFilterIVF33IF3)
class itkInPlaceImageFilterIVF33ISS3(itkImageToImageFilterBPython.itkImageToImageFilterIVF33ISS3):
    r"""Proxy of C++ itkInPlaceImageFilterIVF33ISS3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF33ISS3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF33ISS3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF33ISS3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF33ISS3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF33ISS3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIVF33ISS3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF33ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF33ISS3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIVF33ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF33ISS3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF33ISS3_swigregister(itkInPlaceImageFilterIVF33ISS3)
class itkInPlaceImageFilterIVF33IUC3(itkImageToImageFilterBPython.itkImageToImageFilterIVF33IUC3):
    r"""Proxy of C++ itkInPlaceImageFilterIVF33IUC3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF33IUC3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF33IUC3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF33IUC3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF33IUC3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF33IUC3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIVF33IUC3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF33IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF33IUC3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIVF33IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF33IUC3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF33IUC3_swigregister(itkInPlaceImageFilterIVF33IUC3)
class itkInPlaceImageFilterIVF42IF2(itkImageToImageFilterBPython.itkImageToImageFilterIVF42IF2):
    r"""Proxy of C++ itkInPlaceImageFilterIVF42IF2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF42IF2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF42IF2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF42IF2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF42IF2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF42IF2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIVF42IF2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF42IF2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF42IF2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIVF42IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF42IF2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF42IF2_swigregister(itkInPlaceImageFilterIVF42IF2)
class itkInPlaceImageFilterIVF42ISS2(itkImageToImageFilterBPython.itkImageToImageFilterIVF42ISS2):
    r"""Proxy of C++ itkInPlaceImageFilterIVF42ISS2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF42ISS2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF42ISS2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF42ISS2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF42ISS2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF42ISS2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIVF42ISS2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF42ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF42ISS2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIVF42ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF42ISS2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF42ISS2_swigregister(itkInPlaceImageFilterIVF42ISS2)
class itkInPlaceImageFilterIVF42IUC2(itkImageToImageFilterBPython.itkImageToImageFilterIVF42IUC2):
    r"""Proxy of C++ itkInPlaceImageFilterIVF42IUC2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF42IUC2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF42IUC2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF42IUC2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF42IUC2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF42IUC2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIVF42IUC2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF42IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF42IUC2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIVF42IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF42IUC2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF42IUC2_swigregister(itkInPlaceImageFilterIVF42IUC2)
class itkInPlaceImageFilterIVF43IF3(itkImageToImageFilterBPython.itkImageToImageFilterIVF43IF3):
    r"""Proxy of C++ itkInPlaceImageFilterIVF43IF3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF43IF3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF43IF3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF43IF3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF43IF3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF43IF3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIVF43IF3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF43IF3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF43IF3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIVF43IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF43IF3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF43IF3_swigregister(itkInPlaceImageFilterIVF43IF3)
class itkInPlaceImageFilterIVF43ISS3(itkImageToImageFilterBPython.itkImageToImageFilterIVF43ISS3):
    r"""Proxy of C++ itkInPlaceImageFilterIVF43ISS3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF43ISS3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF43ISS3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF43ISS3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF43ISS3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF43ISS3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIVF43ISS3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF43ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF43ISS3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIVF43ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF43ISS3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF43ISS3_swigregister(itkInPlaceImageFilterIVF43ISS3)
class itkInPlaceImageFilterIVF43IUC3(itkImageToImageFilterBPython.itkImageToImageFilterIVF43IUC3):
    r"""Proxy of C++ itkInPlaceImageFilterIVF43IUC3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF43IUC3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF43IUC3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF43IUC3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF43IUC3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF43IUC3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterIVF43IUC3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF43IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF43IUC3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterIVF43IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterIVF43IUC3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterIVF43IUC3_swigregister(itkInPlaceImageFilterIVF43IUC3)
class itkInPlaceImageFilterVIF2IF2(itkImageToImageFilterBPython.itkImageToImageFilterVIF2IF2):
    r"""Proxy of C++ itkInPlaceImageFilterVIF2IF2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIF2IF2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIF2IF2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIF2IF2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIF2IF2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIF2IF2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterVIF2IF2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIF2IF2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIF2IF2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterVIF2IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterVIF2IF2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIF2IF2_swigregister(itkInPlaceImageFilterVIF2IF2)
class itkInPlaceImageFilterVIF3IF3(itkImageToImageFilterBPython.itkImageToImageFilterVIF3IF3):
    r"""Proxy of C++ itkInPlaceImageFilterVIF3IF3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIF3IF3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIF3IF3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIF3IF3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIF3IF3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIF3IF3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterVIF3IF3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIF3IF3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIF3IF3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterVIF3IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterVIF3IF3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIF3IF3_swigregister(itkInPlaceImageFilterVIF3IF3)
class itkInPlaceImageFilterVISS2ISS2(itkImageToImageFilterBPython.itkImageToImageFilterVISS2ISS2):
    r"""Proxy of C++ itkInPlaceImageFilterVISS2ISS2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVISS2ISS2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVISS2ISS2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVISS2ISS2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVISS2ISS2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVISS2ISS2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterVISS2ISS2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVISS2ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVISS2ISS2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterVISS2ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterVISS2ISS2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVISS2ISS2_swigregister(itkInPlaceImageFilterVISS2ISS2)
class itkInPlaceImageFilterVISS3ISS3(itkImageToImageFilterBPython.itkImageToImageFilterVISS3ISS3):
    r"""Proxy of C++ itkInPlaceImageFilterVISS3ISS3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVISS3ISS3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVISS3ISS3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVISS3ISS3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVISS3ISS3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVISS3ISS3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterVISS3ISS3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVISS3ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVISS3ISS3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterVISS3ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterVISS3ISS3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVISS3ISS3_swigregister(itkInPlaceImageFilterVISS3ISS3)
class itkInPlaceImageFilterVIUC2IUC2(itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IUC2):
    r"""Proxy of C++ itkInPlaceImageFilterVIUC2IUC2 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIUC2IUC2_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIUC2IUC2_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIUC2IUC2_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIUC2IUC2_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIUC2IUC2_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterVIUC2IUC2
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIUC2IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIUC2IUC2_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterVIUC2IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterVIUC2IUC2 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIUC2IUC2_swigregister(itkInPlaceImageFilterVIUC2IUC2)
class itkInPlaceImageFilterVIUC3IUC3(itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IUC3):
    r"""Proxy of C++ itkInPlaceImageFilterVIUC3IUC3 class."""

    thisown = property(lambda x: x.this.own(), 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(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIUC3IUC3_SetInPlace)
    GetInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIUC3IUC3_GetInPlace)
    InPlaceOn = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIUC3IUC3_InPlaceOn)
    InPlaceOff = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIUC3IUC3_InPlaceOff)
    CanRunInPlace = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIUC3IUC3_CanRunInPlace)
    __swig_destroy__ = _itkInPlaceImageFilterBPython.delete_itkInPlaceImageFilterVIUC3IUC3
    cast = _swig_new_static_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIUC3IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIUC3IUC3_GetPointer)

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

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

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

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

        Ex:

          itkInPlaceImageFilterVIUC3IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkInPlaceImageFilterVIUC3IUC3 in _itkInPlaceImageFilterBPython:
_itkInPlaceImageFilterBPython.itkInPlaceImageFilterVIUC3IUC3_swigregister(itkInPlaceImageFilterVIUC3IUC3)

