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

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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

def itkMaskImageFilterICF3IUC3ICF3_New():
  return itkMaskImageFilterICF3IUC3ICF3.New()


def itkMaskImageFilterICF3IUC3ICF3_Superclass_New():
  return itkMaskImageFilterICF3IUC3ICF3_Superclass.New()


def itkMaskImageFilterICF2IUC2ICF2_New():
  return itkMaskImageFilterICF2IUC2ICF2.New()


def itkMaskImageFilterICF2IUC2ICF2_Superclass_New():
  return itkMaskImageFilterICF2IUC2ICF2_Superclass.New()


def itkMaskImageFilterICF3ISS3ICF3_New():
  return itkMaskImageFilterICF3ISS3ICF3.New()


def itkMaskImageFilterICF3ISS3ICF3_Superclass_New():
  return itkMaskImageFilterICF3ISS3ICF3_Superclass.New()


def itkMaskImageFilterICF2ISS2ICF2_New():
  return itkMaskImageFilterICF2ISS2ICF2.New()


def itkMaskImageFilterICF2ISS2ICF2_Superclass_New():
  return itkMaskImageFilterICF2ISS2ICF2_Superclass.New()


def itkMaskImageFilterIF3IUC3IF3_New():
  return itkMaskImageFilterIF3IUC3IF3.New()


def itkMaskImageFilterIF3IUC3IF3_Superclass_New():
  return itkMaskImageFilterIF3IUC3IF3_Superclass.New()


def itkMaskImageFilterIF2IUC2IF2_New():
  return itkMaskImageFilterIF2IUC2IF2.New()


def itkMaskImageFilterIF2IUC2IF2_Superclass_New():
  return itkMaskImageFilterIF2IUC2IF2_Superclass.New()


def itkMaskImageFilterIF3ISS3IF3_New():
  return itkMaskImageFilterIF3ISS3IF3.New()


def itkMaskImageFilterIF3ISS3IF3_Superclass_New():
  return itkMaskImageFilterIF3ISS3IF3_Superclass.New()


def itkMaskImageFilterIF2ISS2IF2_New():
  return itkMaskImageFilterIF2ISS2IF2.New()


def itkMaskImageFilterIF2ISS2IF2_Superclass_New():
  return itkMaskImageFilterIF2ISS2IF2_Superclass.New()


def itkMaskImageFilterIUC3IUC3IUC3_New():
  return itkMaskImageFilterIUC3IUC3IUC3.New()


def itkMaskImageFilterIUC3IUC3IUC3_Superclass_New():
  return itkMaskImageFilterIUC3IUC3IUC3_Superclass.New()


def itkMaskImageFilterIUC2IUC2IUC2_New():
  return itkMaskImageFilterIUC2IUC2IUC2.New()


def itkMaskImageFilterIUC2IUC2IUC2_Superclass_New():
  return itkMaskImageFilterIUC2IUC2IUC2_Superclass.New()


def itkMaskImageFilterIUC3ISS3IUC3_New():
  return itkMaskImageFilterIUC3ISS3IUC3.New()


def itkMaskImageFilterIUC3ISS3IUC3_Superclass_New():
  return itkMaskImageFilterIUC3ISS3IUC3_Superclass.New()


def itkMaskImageFilterIUC2ISS2IUC2_New():
  return itkMaskImageFilterIUC2ISS2IUC2.New()


def itkMaskImageFilterIUC2ISS2IUC2_Superclass_New():
  return itkMaskImageFilterIUC2ISS2IUC2_Superclass.New()


def itkMaskImageFilterISS3IUC3ISS3_New():
  return itkMaskImageFilterISS3IUC3ISS3.New()


def itkMaskImageFilterISS3IUC3ISS3_Superclass_New():
  return itkMaskImageFilterISS3IUC3ISS3_Superclass.New()


def itkMaskImageFilterISS2IUC2ISS2_New():
  return itkMaskImageFilterISS2IUC2ISS2.New()


def itkMaskImageFilterISS2IUC2ISS2_Superclass_New():
  return itkMaskImageFilterISS2IUC2ISS2_Superclass.New()


def itkMaskImageFilterISS3ISS3ISS3_New():
  return itkMaskImageFilterISS3ISS3ISS3.New()


def itkMaskImageFilterISS3ISS3ISS3_Superclass_New():
  return itkMaskImageFilterISS3ISS3ISS3_Superclass.New()


def itkMaskImageFilterISS2ISS2ISS2_New():
  return itkMaskImageFilterISS2ISS2ISS2.New()


def itkMaskImageFilterISS2ISS2ISS2_Superclass_New():
  return itkMaskImageFilterISS2ISS2ISS2_Superclass.New()


def itkMaskImageFilterICVF43IUC3ICVF43_New():
  return itkMaskImageFilterICVF43IUC3ICVF43.New()


def itkMaskImageFilterICVF43IUC3ICVF43_Superclass_New():
  return itkMaskImageFilterICVF43IUC3ICVF43_Superclass.New()


def itkMaskImageFilterICVF42IUC2ICVF42_New():
  return itkMaskImageFilterICVF42IUC2ICVF42.New()


def itkMaskImageFilterICVF42IUC2ICVF42_Superclass_New():
  return itkMaskImageFilterICVF42IUC2ICVF42_Superclass.New()


def itkMaskImageFilterICVF33IUC3ICVF33_New():
  return itkMaskImageFilterICVF33IUC3ICVF33.New()


def itkMaskImageFilterICVF33IUC3ICVF33_Superclass_New():
  return itkMaskImageFilterICVF33IUC3ICVF33_Superclass.New()


def itkMaskImageFilterICVF32IUC2ICVF32_New():
  return itkMaskImageFilterICVF32IUC2ICVF32.New()


def itkMaskImageFilterICVF32IUC2ICVF32_Superclass_New():
  return itkMaskImageFilterICVF32IUC2ICVF32_Superclass.New()


def itkMaskImageFilterICVF23IUC3ICVF23_New():
  return itkMaskImageFilterICVF23IUC3ICVF23.New()


def itkMaskImageFilterICVF23IUC3ICVF23_Superclass_New():
  return itkMaskImageFilterICVF23IUC3ICVF23_Superclass.New()


def itkMaskImageFilterICVF22IUC2ICVF22_New():
  return itkMaskImageFilterICVF22IUC2ICVF22.New()


def itkMaskImageFilterICVF22IUC2ICVF22_Superclass_New():
  return itkMaskImageFilterICVF22IUC2ICVF22_Superclass.New()


def itkMaskImageFilterICVF43ISS3ICVF43_New():
  return itkMaskImageFilterICVF43ISS3ICVF43.New()


def itkMaskImageFilterICVF43ISS3ICVF43_Superclass_New():
  return itkMaskImageFilterICVF43ISS3ICVF43_Superclass.New()


def itkMaskImageFilterICVF42ISS2ICVF42_New():
  return itkMaskImageFilterICVF42ISS2ICVF42.New()


def itkMaskImageFilterICVF42ISS2ICVF42_Superclass_New():
  return itkMaskImageFilterICVF42ISS2ICVF42_Superclass.New()


def itkMaskImageFilterICVF33ISS3ICVF33_New():
  return itkMaskImageFilterICVF33ISS3ICVF33.New()


def itkMaskImageFilterICVF33ISS3ICVF33_Superclass_New():
  return itkMaskImageFilterICVF33ISS3ICVF33_Superclass.New()


def itkMaskImageFilterICVF32ISS2ICVF32_New():
  return itkMaskImageFilterICVF32ISS2ICVF32.New()


def itkMaskImageFilterICVF32ISS2ICVF32_Superclass_New():
  return itkMaskImageFilterICVF32ISS2ICVF32_Superclass.New()


def itkMaskImageFilterICVF23ISS3ICVF23_New():
  return itkMaskImageFilterICVF23ISS3ICVF23.New()


def itkMaskImageFilterICVF23ISS3ICVF23_Superclass_New():
  return itkMaskImageFilterICVF23ISS3ICVF23_Superclass.New()


def itkMaskImageFilterICVF22ISS2ICVF22_New():
  return itkMaskImageFilterICVF22ISS2ICVF22.New()


def itkMaskImageFilterICVF22ISS2ICVF22_Superclass_New():
  return itkMaskImageFilterICVF22ISS2ICVF22_Superclass.New()


def itkMaskImageFilterIVF43IUC3IVF43_New():
  return itkMaskImageFilterIVF43IUC3IVF43.New()


def itkMaskImageFilterIVF43IUC3IVF43_Superclass_New():
  return itkMaskImageFilterIVF43IUC3IVF43_Superclass.New()


def itkMaskImageFilterIVF42IUC2IVF42_New():
  return itkMaskImageFilterIVF42IUC2IVF42.New()


def itkMaskImageFilterIVF42IUC2IVF42_Superclass_New():
  return itkMaskImageFilterIVF42IUC2IVF42_Superclass.New()


def itkMaskImageFilterIVF33IUC3IVF33_New():
  return itkMaskImageFilterIVF33IUC3IVF33.New()


def itkMaskImageFilterIVF33IUC3IVF33_Superclass_New():
  return itkMaskImageFilterIVF33IUC3IVF33_Superclass.New()


def itkMaskImageFilterIVF32IUC2IVF32_New():
  return itkMaskImageFilterIVF32IUC2IVF32.New()


def itkMaskImageFilterIVF32IUC2IVF32_Superclass_New():
  return itkMaskImageFilterIVF32IUC2IVF32_Superclass.New()


def itkMaskImageFilterIVF23IUC3IVF23_New():
  return itkMaskImageFilterIVF23IUC3IVF23.New()


def itkMaskImageFilterIVF23IUC3IVF23_Superclass_New():
  return itkMaskImageFilterIVF23IUC3IVF23_Superclass.New()


def itkMaskImageFilterIVF22IUC2IVF22_New():
  return itkMaskImageFilterIVF22IUC2IVF22.New()


def itkMaskImageFilterIVF22IUC2IVF22_Superclass_New():
  return itkMaskImageFilterIVF22IUC2IVF22_Superclass.New()


def itkMaskImageFilterIVF43ISS3IVF43_New():
  return itkMaskImageFilterIVF43ISS3IVF43.New()


def itkMaskImageFilterIVF43ISS3IVF43_Superclass_New():
  return itkMaskImageFilterIVF43ISS3IVF43_Superclass.New()


def itkMaskImageFilterIVF42ISS2IVF42_New():
  return itkMaskImageFilterIVF42ISS2IVF42.New()


def itkMaskImageFilterIVF42ISS2IVF42_Superclass_New():
  return itkMaskImageFilterIVF42ISS2IVF42_Superclass.New()


def itkMaskImageFilterIVF33ISS3IVF33_New():
  return itkMaskImageFilterIVF33ISS3IVF33.New()


def itkMaskImageFilterIVF33ISS3IVF33_Superclass_New():
  return itkMaskImageFilterIVF33ISS3IVF33_Superclass.New()


def itkMaskImageFilterIVF32ISS2IVF32_New():
  return itkMaskImageFilterIVF32ISS2IVF32.New()


def itkMaskImageFilterIVF32ISS2IVF32_Superclass_New():
  return itkMaskImageFilterIVF32ISS2IVF32_Superclass.New()


def itkMaskImageFilterIVF23ISS3IVF23_New():
  return itkMaskImageFilterIVF23ISS3IVF23.New()


def itkMaskImageFilterIVF23ISS3IVF23_Superclass_New():
  return itkMaskImageFilterIVF23ISS3IVF23_Superclass.New()


def itkMaskImageFilterIVF22ISS2IVF22_New():
  return itkMaskImageFilterIVF22ISS2IVF22.New()


def itkMaskImageFilterIVF22ISS2IVF22_Superclass_New():
  return itkMaskImageFilterIVF22ISS2IVF22_Superclass.New()


def itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_New():
  return itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3.New()


def itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_New():
  return itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass.New()


def itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_New():
  return itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2.New()


def itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_New():
  return itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass.New()


def itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_New():
  return itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3.New()


def itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_New():
  return itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass.New()


def itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_New():
  return itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2.New()


def itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_New():
  return itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass.New()


def itkMaskImageFilterIRGBUC3IUC3IRGBUC3_New():
  return itkMaskImageFilterIRGBUC3IUC3IRGBUC3.New()


def itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Superclass_New():
  return itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Superclass.New()


def itkMaskImageFilterIRGBUC2IUC2IRGBUC2_New():
  return itkMaskImageFilterIRGBUC2IUC2IRGBUC2.New()


def itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Superclass_New():
  return itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Superclass.New()


def itkMaskImageFilterIRGBUC3ISS3IRGBUC3_New():
  return itkMaskImageFilterIRGBUC3ISS3IRGBUC3.New()


def itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Superclass_New():
  return itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Superclass.New()


def itkMaskImageFilterIRGBUC2ISS2IRGBUC2_New():
  return itkMaskImageFilterIRGBUC2ISS2IRGBUC2.New()


def itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Superclass_New():
  return itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Superclass.New()

class itkMaskImageFilterICF2ISS2ICF2_Superclass(itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF2ICF2):
    r"""Proxy of C++ itkMaskImageFilterICF2ISS2ICF2_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICF2ISS2ICF2_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICF2ISS2ICF2_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICF2ISS2ICF2_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_Superclass_swigregister(itkMaskImageFilterICF2ISS2ICF2_Superclass)
class itkMaskImageFilterICF2IUC2ICF2_Superclass(itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF2ICF2):
    r"""Proxy of C++ itkMaskImageFilterICF2IUC2ICF2_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICF2IUC2ICF2_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICF2IUC2ICF2_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICF2IUC2ICF2_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_Superclass_swigregister(itkMaskImageFilterICF2IUC2ICF2_Superclass)
class itkMaskImageFilterICF3ISS3ICF3_Superclass(itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3ICF3):
    r"""Proxy of C++ itkMaskImageFilterICF3ISS3ICF3_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICF3ISS3ICF3_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICF3ISS3ICF3_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICF3ISS3ICF3_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_Superclass_swigregister(itkMaskImageFilterICF3ISS3ICF3_Superclass)
class itkMaskImageFilterICF3IUC3ICF3_Superclass(itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3ICF3):
    r"""Proxy of C++ itkMaskImageFilterICF3IUC3ICF3_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICF3IUC3ICF3_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICF3IUC3ICF3_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICF3IUC3ICF3_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_Superclass_swigregister(itkMaskImageFilterICF3IUC3ICF3_Superclass)
class itkMaskImageFilterICVF22ISS2ICVF22_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF22ICVF22):
    r"""Proxy of C++ itkMaskImageFilterICVF22ISS2ICVF22_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF22ISS2ICVF22_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICVF22ISS2ICVF22_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICVF22ISS2ICVF22_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_Superclass_swigregister(itkMaskImageFilterICVF22ISS2ICVF22_Superclass)
class itkMaskImageFilterICVF22IUC2ICVF22_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF22ICVF22):
    r"""Proxy of C++ itkMaskImageFilterICVF22IUC2ICVF22_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF22IUC2ICVF22_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICVF22IUC2ICVF22_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICVF22IUC2ICVF22_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_Superclass_swigregister(itkMaskImageFilterICVF22IUC2ICVF22_Superclass)
class itkMaskImageFilterICVF23ISS3ICVF23_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF23ICVF23):
    r"""Proxy of C++ itkMaskImageFilterICVF23ISS3ICVF23_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF23ISS3ICVF23_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICVF23ISS3ICVF23_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICVF23ISS3ICVF23_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_Superclass_swigregister(itkMaskImageFilterICVF23ISS3ICVF23_Superclass)
class itkMaskImageFilterICVF23IUC3ICVF23_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF23ICVF23):
    r"""Proxy of C++ itkMaskImageFilterICVF23IUC3ICVF23_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF23IUC3ICVF23_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICVF23IUC3ICVF23_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICVF23IUC3ICVF23_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_Superclass_swigregister(itkMaskImageFilterICVF23IUC3ICVF23_Superclass)
class itkMaskImageFilterICVF32ISS2ICVF32_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF32ICVF32):
    r"""Proxy of C++ itkMaskImageFilterICVF32ISS2ICVF32_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF32ISS2ICVF32_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICVF32ISS2ICVF32_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICVF32ISS2ICVF32_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_Superclass_swigregister(itkMaskImageFilterICVF32ISS2ICVF32_Superclass)
class itkMaskImageFilterICVF32IUC2ICVF32_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF32ICVF32):
    r"""Proxy of C++ itkMaskImageFilterICVF32IUC2ICVF32_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF32IUC2ICVF32_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICVF32IUC2ICVF32_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICVF32IUC2ICVF32_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_Superclass_swigregister(itkMaskImageFilterICVF32IUC2ICVF32_Superclass)
class itkMaskImageFilterICVF33ISS3ICVF33_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF33ICVF33):
    r"""Proxy of C++ itkMaskImageFilterICVF33ISS3ICVF33_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF33ISS3ICVF33_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICVF33ISS3ICVF33_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICVF33ISS3ICVF33_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_Superclass_swigregister(itkMaskImageFilterICVF33ISS3ICVF33_Superclass)
class itkMaskImageFilterICVF33IUC3ICVF33_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF33ICVF33):
    r"""Proxy of C++ itkMaskImageFilterICVF33IUC3ICVF33_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF33IUC3ICVF33_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICVF33IUC3ICVF33_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICVF33IUC3ICVF33_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_Superclass_swigregister(itkMaskImageFilterICVF33IUC3ICVF33_Superclass)
class itkMaskImageFilterICVF42ISS2ICVF42_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF42ICVF42):
    r"""Proxy of C++ itkMaskImageFilterICVF42ISS2ICVF42_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF42ISS2ICVF42_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICVF42ISS2ICVF42_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICVF42ISS2ICVF42_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_Superclass_swigregister(itkMaskImageFilterICVF42ISS2ICVF42_Superclass)
class itkMaskImageFilterICVF42IUC2ICVF42_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF42ICVF42):
    r"""Proxy of C++ itkMaskImageFilterICVF42IUC2ICVF42_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF42IUC2ICVF42_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICVF42IUC2ICVF42_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICVF42IUC2ICVF42_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_Superclass_swigregister(itkMaskImageFilterICVF42IUC2ICVF42_Superclass)
class itkMaskImageFilterICVF43ISS3ICVF43_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF43ICVF43):
    r"""Proxy of C++ itkMaskImageFilterICVF43ISS3ICVF43_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF43ISS3ICVF43_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICVF43ISS3ICVF43_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICVF43ISS3ICVF43_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_Superclass_swigregister(itkMaskImageFilterICVF43ISS3ICVF43_Superclass)
class itkMaskImageFilterICVF43IUC3ICVF43_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF43ICVF43):
    r"""Proxy of C++ itkMaskImageFilterICVF43IUC3ICVF43_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF43IUC3ICVF43_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICVF43IUC3ICVF43_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICVF43IUC3ICVF43_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_Superclass_swigregister(itkMaskImageFilterICVF43IUC3ICVF43_Superclass)
class itkMaskImageFilterIF2ISS2IF2_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IF2):
    r"""Proxy of C++ itkMaskImageFilterIF2ISS2IF2_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIF2ISS2IF2_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIF2ISS2IF2_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIF2ISS2IF2_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_Superclass_swigregister(itkMaskImageFilterIF2ISS2IF2_Superclass)
class itkMaskImageFilterIF2IUC2IF2_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IF2):
    r"""Proxy of C++ itkMaskImageFilterIF2IUC2IF2_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIF2IUC2IF2_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIF2IUC2IF2_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIF2IUC2IF2_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_Superclass_swigregister(itkMaskImageFilterIF2IUC2IF2_Superclass)
class itkMaskImageFilterIF3ISS3IF3_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IF3):
    r"""Proxy of C++ itkMaskImageFilterIF3ISS3IF3_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIF3ISS3IF3_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIF3ISS3IF3_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIF3ISS3IF3_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_Superclass_swigregister(itkMaskImageFilterIF3ISS3IF3_Superclass)
class itkMaskImageFilterIF3IUC3IF3_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IF3):
    r"""Proxy of C++ itkMaskImageFilterIF3IUC3IF3_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIF3IUC3IF3_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIF3IUC3IF3_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIF3IUC3IF3_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_Superclass_swigregister(itkMaskImageFilterIF3IUC3IF3_Superclass)
class itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC2IRGBAUC2):
    r"""Proxy of C++ itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_swigregister(itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass)
class itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC2IRGBAUC2):
    r"""Proxy of C++ itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_swigregister(itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass)
class itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC3IRGBAUC3):
    r"""Proxy of C++ itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_swigregister(itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass)
class itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC3IRGBAUC3):
    r"""Proxy of C++ itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_swigregister(itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass)
class itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC2IRGBUC2):
    r"""Proxy of C++ itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Superclass_swigregister(itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Superclass)
class itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC2IRGBUC2):
    r"""Proxy of C++ itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Superclass_swigregister(itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Superclass)
class itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC3IRGBUC3):
    r"""Proxy of C++ itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Superclass_swigregister(itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Superclass)
class itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC3IRGBUC3):
    r"""Proxy of C++ itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Superclass_swigregister(itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Superclass)
class itkMaskImageFilterISS2ISS2ISS2_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2ISS2):
    r"""Proxy of C++ itkMaskImageFilterISS2ISS2ISS2_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterISS2ISS2ISS2_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterISS2ISS2ISS2_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterISS2ISS2ISS2_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_Superclass_swigregister(itkMaskImageFilterISS2ISS2ISS2_Superclass)
class itkMaskImageFilterISS2IUC2ISS2_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2ISS2):
    r"""Proxy of C++ itkMaskImageFilterISS2IUC2ISS2_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterISS2IUC2ISS2_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterISS2IUC2ISS2_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterISS2IUC2ISS2_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_Superclass_swigregister(itkMaskImageFilterISS2IUC2ISS2_Superclass)
class itkMaskImageFilterISS3ISS3ISS3_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3ISS3):
    r"""Proxy of C++ itkMaskImageFilterISS3ISS3ISS3_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterISS3ISS3ISS3_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterISS3ISS3ISS3_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterISS3ISS3ISS3_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_Superclass_swigregister(itkMaskImageFilterISS3ISS3ISS3_Superclass)
class itkMaskImageFilterISS3IUC3ISS3_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3ISS3):
    r"""Proxy of C++ itkMaskImageFilterISS3IUC3ISS3_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterISS3IUC3ISS3_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterISS3IUC3ISS3_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterISS3IUC3ISS3_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_Superclass_swigregister(itkMaskImageFilterISS3IUC3ISS3_Superclass)
class itkMaskImageFilterIUC2ISS2IUC2_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IUC2):
    r"""Proxy of C++ itkMaskImageFilterIUC2ISS2IUC2_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIUC2ISS2IUC2_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIUC2ISS2IUC2_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIUC2ISS2IUC2_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_Superclass_swigregister(itkMaskImageFilterIUC2ISS2IUC2_Superclass)
class itkMaskImageFilterIUC2IUC2IUC2_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IUC2):
    r"""Proxy of C++ itkMaskImageFilterIUC2IUC2IUC2_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIUC2IUC2IUC2_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIUC2IUC2IUC2_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIUC2IUC2IUC2_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_Superclass_swigregister(itkMaskImageFilterIUC2IUC2IUC2_Superclass)
class itkMaskImageFilterIUC3ISS3IUC3_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IUC3):
    r"""Proxy of C++ itkMaskImageFilterIUC3ISS3IUC3_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIUC3ISS3IUC3_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIUC3ISS3IUC3_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIUC3ISS3IUC3_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_Superclass_swigregister(itkMaskImageFilterIUC3ISS3IUC3_Superclass)
class itkMaskImageFilterIUC3IUC3IUC3_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IUC3):
    r"""Proxy of C++ itkMaskImageFilterIUC3IUC3IUC3_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIUC3IUC3IUC3_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIUC3IUC3IUC3_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIUC3IUC3IUC3_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_Superclass_swigregister(itkMaskImageFilterIUC3IUC3IUC3_Superclass)
class itkMaskImageFilterIVF22ISS2IVF22_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF22IVF22):
    r"""Proxy of C++ itkMaskImageFilterIVF22ISS2IVF22_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF22ISS2IVF22_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIVF22ISS2IVF22_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIVF22ISS2IVF22_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_Superclass_swigregister(itkMaskImageFilterIVF22ISS2IVF22_Superclass)
class itkMaskImageFilterIVF22IUC2IVF22_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF22IVF22):
    r"""Proxy of C++ itkMaskImageFilterIVF22IUC2IVF22_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF22IUC2IVF22_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIVF22IUC2IVF22_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIVF22IUC2IVF22_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_Superclass_swigregister(itkMaskImageFilterIVF22IUC2IVF22_Superclass)
class itkMaskImageFilterIVF23ISS3IVF23_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF23IVF23):
    r"""Proxy of C++ itkMaskImageFilterIVF23ISS3IVF23_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF23ISS3IVF23_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIVF23ISS3IVF23_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIVF23ISS3IVF23_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_Superclass_swigregister(itkMaskImageFilterIVF23ISS3IVF23_Superclass)
class itkMaskImageFilterIVF23IUC3IVF23_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF23IVF23):
    r"""Proxy of C++ itkMaskImageFilterIVF23IUC3IVF23_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF23IUC3IVF23_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIVF23IUC3IVF23_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIVF23IUC3IVF23_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_Superclass_swigregister(itkMaskImageFilterIVF23IUC3IVF23_Superclass)
class itkMaskImageFilterIVF32ISS2IVF32_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF32IVF32):
    r"""Proxy of C++ itkMaskImageFilterIVF32ISS2IVF32_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF32ISS2IVF32_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIVF32ISS2IVF32_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIVF32ISS2IVF32_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_Superclass_swigregister(itkMaskImageFilterIVF32ISS2IVF32_Superclass)
class itkMaskImageFilterIVF32IUC2IVF32_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF32IVF32):
    r"""Proxy of C++ itkMaskImageFilterIVF32IUC2IVF32_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF32IUC2IVF32_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIVF32IUC2IVF32_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIVF32IUC2IVF32_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_Superclass_swigregister(itkMaskImageFilterIVF32IUC2IVF32_Superclass)
class itkMaskImageFilterIVF33ISS3IVF33_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF33IVF33):
    r"""Proxy of C++ itkMaskImageFilterIVF33ISS3IVF33_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF33ISS3IVF33_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIVF33ISS3IVF33_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIVF33ISS3IVF33_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_Superclass_swigregister(itkMaskImageFilterIVF33ISS3IVF33_Superclass)
class itkMaskImageFilterIVF33IUC3IVF33_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF33IVF33):
    r"""Proxy of C++ itkMaskImageFilterIVF33IUC3IVF33_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF33IUC3IVF33_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIVF33IUC3IVF33_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIVF33IUC3IVF33_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_Superclass_swigregister(itkMaskImageFilterIVF33IUC3IVF33_Superclass)
class itkMaskImageFilterIVF42ISS2IVF42_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF42IVF42):
    r"""Proxy of C++ itkMaskImageFilterIVF42ISS2IVF42_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF42ISS2IVF42_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIVF42ISS2IVF42_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIVF42ISS2IVF42_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_Superclass_swigregister(itkMaskImageFilterIVF42ISS2IVF42_Superclass)
class itkMaskImageFilterIVF42IUC2IVF42_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF42IVF42):
    r"""Proxy of C++ itkMaskImageFilterIVF42IUC2IVF42_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF42IUC2IVF42_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIVF42IUC2IVF42_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIVF42IUC2IVF42_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_Superclass_swigregister(itkMaskImageFilterIVF42IUC2IVF42_Superclass)
class itkMaskImageFilterIVF43ISS3IVF43_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF43IVF43):
    r"""Proxy of C++ itkMaskImageFilterIVF43ISS3IVF43_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF43ISS3IVF43_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIVF43ISS3IVF43_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIVF43ISS3IVF43_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_Superclass_swigregister(itkMaskImageFilterIVF43ISS3IVF43_Superclass)
class itkMaskImageFilterIVF43IUC3IVF43_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF43IVF43):
    r"""Proxy of C++ itkMaskImageFilterIVF43IUC3IVF43_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF43IUC3IVF43_Superclass
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIVF43IUC3IVF43_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIVF43IUC3IVF43_Superclass in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_Superclass_swigregister(itkMaskImageFilterIVF43IUC3IVF43_Superclass)
class itkMaskImageFilterICF2ISS2ICF2(itkMaskImageFilterICF2ISS2ICF2_Superclass):
    r"""Proxy of C++ itkMaskImageFilterICF2ISS2ICF2 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICF2ISS2ICF2
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICF2ISS2ICF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICF2ISS2ICF2 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_swigregister(itkMaskImageFilterICF2ISS2ICF2)
class itkMaskImageFilterICF2IUC2ICF2(itkMaskImageFilterICF2IUC2ICF2_Superclass):
    r"""Proxy of C++ itkMaskImageFilterICF2IUC2ICF2 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICF2IUC2ICF2
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICF2IUC2ICF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICF2IUC2ICF2 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_swigregister(itkMaskImageFilterICF2IUC2ICF2)
class itkMaskImageFilterICF3ISS3ICF3(itkMaskImageFilterICF3ISS3ICF3_Superclass):
    r"""Proxy of C++ itkMaskImageFilterICF3ISS3ICF3 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICF3ISS3ICF3
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICF3ISS3ICF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICF3ISS3ICF3 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_swigregister(itkMaskImageFilterICF3ISS3ICF3)
class itkMaskImageFilterICF3IUC3ICF3(itkMaskImageFilterICF3IUC3ICF3_Superclass):
    r"""Proxy of C++ itkMaskImageFilterICF3IUC3ICF3 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICF3IUC3ICF3
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICF3IUC3ICF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICF3IUC3ICF3 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_swigregister(itkMaskImageFilterICF3IUC3ICF3)
class itkMaskImageFilterICVF22ISS2ICVF22(itkMaskImageFilterICVF22ISS2ICVF22_Superclass):
    r"""Proxy of C++ itkMaskImageFilterICVF22ISS2ICVF22 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF22ISS2ICVF22
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICVF22ISS2ICVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICVF22ISS2ICVF22 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_swigregister(itkMaskImageFilterICVF22ISS2ICVF22)
class itkMaskImageFilterICVF22IUC2ICVF22(itkMaskImageFilterICVF22IUC2ICVF22_Superclass):
    r"""Proxy of C++ itkMaskImageFilterICVF22IUC2ICVF22 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF22IUC2ICVF22
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICVF22IUC2ICVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICVF22IUC2ICVF22 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_swigregister(itkMaskImageFilterICVF22IUC2ICVF22)
class itkMaskImageFilterICVF23ISS3ICVF23(itkMaskImageFilterICVF23ISS3ICVF23_Superclass):
    r"""Proxy of C++ itkMaskImageFilterICVF23ISS3ICVF23 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF23ISS3ICVF23
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICVF23ISS3ICVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICVF23ISS3ICVF23 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_swigregister(itkMaskImageFilterICVF23ISS3ICVF23)
class itkMaskImageFilterICVF23IUC3ICVF23(itkMaskImageFilterICVF23IUC3ICVF23_Superclass):
    r"""Proxy of C++ itkMaskImageFilterICVF23IUC3ICVF23 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF23IUC3ICVF23
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICVF23IUC3ICVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICVF23IUC3ICVF23 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_swigregister(itkMaskImageFilterICVF23IUC3ICVF23)
class itkMaskImageFilterICVF32ISS2ICVF32(itkMaskImageFilterICVF32ISS2ICVF32_Superclass):
    r"""Proxy of C++ itkMaskImageFilterICVF32ISS2ICVF32 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF32ISS2ICVF32
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICVF32ISS2ICVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICVF32ISS2ICVF32 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_swigregister(itkMaskImageFilterICVF32ISS2ICVF32)
class itkMaskImageFilterICVF32IUC2ICVF32(itkMaskImageFilterICVF32IUC2ICVF32_Superclass):
    r"""Proxy of C++ itkMaskImageFilterICVF32IUC2ICVF32 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF32IUC2ICVF32
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICVF32IUC2ICVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICVF32IUC2ICVF32 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_swigregister(itkMaskImageFilterICVF32IUC2ICVF32)
class itkMaskImageFilterICVF33ISS3ICVF33(itkMaskImageFilterICVF33ISS3ICVF33_Superclass):
    r"""Proxy of C++ itkMaskImageFilterICVF33ISS3ICVF33 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF33ISS3ICVF33
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICVF33ISS3ICVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICVF33ISS3ICVF33 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_swigregister(itkMaskImageFilterICVF33ISS3ICVF33)
class itkMaskImageFilterICVF33IUC3ICVF33(itkMaskImageFilterICVF33IUC3ICVF33_Superclass):
    r"""Proxy of C++ itkMaskImageFilterICVF33IUC3ICVF33 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF33IUC3ICVF33
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICVF33IUC3ICVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICVF33IUC3ICVF33 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_swigregister(itkMaskImageFilterICVF33IUC3ICVF33)
class itkMaskImageFilterICVF42ISS2ICVF42(itkMaskImageFilterICVF42ISS2ICVF42_Superclass):
    r"""Proxy of C++ itkMaskImageFilterICVF42ISS2ICVF42 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF42ISS2ICVF42
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICVF42ISS2ICVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICVF42ISS2ICVF42 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_swigregister(itkMaskImageFilterICVF42ISS2ICVF42)
class itkMaskImageFilterICVF42IUC2ICVF42(itkMaskImageFilterICVF42IUC2ICVF42_Superclass):
    r"""Proxy of C++ itkMaskImageFilterICVF42IUC2ICVF42 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF42IUC2ICVF42
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICVF42IUC2ICVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICVF42IUC2ICVF42 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_swigregister(itkMaskImageFilterICVF42IUC2ICVF42)
class itkMaskImageFilterICVF43ISS3ICVF43(itkMaskImageFilterICVF43ISS3ICVF43_Superclass):
    r"""Proxy of C++ itkMaskImageFilterICVF43ISS3ICVF43 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF43ISS3ICVF43
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICVF43ISS3ICVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICVF43ISS3ICVF43 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_swigregister(itkMaskImageFilterICVF43ISS3ICVF43)
class itkMaskImageFilterICVF43IUC3ICVF43(itkMaskImageFilterICVF43IUC3ICVF43_Superclass):
    r"""Proxy of C++ itkMaskImageFilterICVF43IUC3ICVF43 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF43IUC3ICVF43
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterICVF43IUC3ICVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterICVF43IUC3ICVF43 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_swigregister(itkMaskImageFilterICVF43IUC3ICVF43)
class itkMaskImageFilterIF2ISS2IF2(itkMaskImageFilterIF2ISS2IF2_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIF2ISS2IF2 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIF2ISS2IF2
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIF2ISS2IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIF2ISS2IF2 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_swigregister(itkMaskImageFilterIF2ISS2IF2)
class itkMaskImageFilterIF2IUC2IF2(itkMaskImageFilterIF2IUC2IF2_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIF2IUC2IF2 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIF2IUC2IF2
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIF2IUC2IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIF2IUC2IF2 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_swigregister(itkMaskImageFilterIF2IUC2IF2)
class itkMaskImageFilterIF3ISS3IF3(itkMaskImageFilterIF3ISS3IF3_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIF3ISS3IF3 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIF3ISS3IF3
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIF3ISS3IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIF3ISS3IF3 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_swigregister(itkMaskImageFilterIF3ISS3IF3)
class itkMaskImageFilterIF3IUC3IF3(itkMaskImageFilterIF3IUC3IF3_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIF3IUC3IF3 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIF3IUC3IF3
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIF3IUC3IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIF3IUC3IF3 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_swigregister(itkMaskImageFilterIF3IUC3IF3)
class itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2(itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_swigregister(itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2)
class itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2(itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_swigregister(itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2)
class itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3(itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_swigregister(itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3)
class itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3(itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_swigregister(itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3)
class itkMaskImageFilterIRGBUC2ISS2IRGBUC2(itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIRGBUC2ISS2IRGBUC2 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIRGBUC2ISS2IRGBUC2
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIRGBUC2ISS2IRGBUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIRGBUC2ISS2IRGBUC2 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_swigregister(itkMaskImageFilterIRGBUC2ISS2IRGBUC2)
class itkMaskImageFilterIRGBUC2IUC2IRGBUC2(itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIRGBUC2IUC2IRGBUC2 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIRGBUC2IUC2IRGBUC2
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIRGBUC2IUC2IRGBUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIRGBUC2IUC2IRGBUC2 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_swigregister(itkMaskImageFilterIRGBUC2IUC2IRGBUC2)
class itkMaskImageFilterIRGBUC3ISS3IRGBUC3(itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIRGBUC3ISS3IRGBUC3 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIRGBUC3ISS3IRGBUC3
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIRGBUC3ISS3IRGBUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIRGBUC3ISS3IRGBUC3 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_swigregister(itkMaskImageFilterIRGBUC3ISS3IRGBUC3)
class itkMaskImageFilterIRGBUC3IUC3IRGBUC3(itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIRGBUC3IUC3IRGBUC3 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIRGBUC3IUC3IRGBUC3
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIRGBUC3IUC3IRGBUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIRGBUC3IUC3IRGBUC3 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_swigregister(itkMaskImageFilterIRGBUC3IUC3IRGBUC3)
class itkMaskImageFilterISS2ISS2ISS2(itkMaskImageFilterISS2ISS2ISS2_Superclass):
    r"""Proxy of C++ itkMaskImageFilterISS2ISS2ISS2 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterISS2ISS2ISS2
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterISS2ISS2ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterISS2ISS2ISS2 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_swigregister(itkMaskImageFilterISS2ISS2ISS2)
class itkMaskImageFilterISS2IUC2ISS2(itkMaskImageFilterISS2IUC2ISS2_Superclass):
    r"""Proxy of C++ itkMaskImageFilterISS2IUC2ISS2 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterISS2IUC2ISS2
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterISS2IUC2ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterISS2IUC2ISS2 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_swigregister(itkMaskImageFilterISS2IUC2ISS2)
class itkMaskImageFilterISS3ISS3ISS3(itkMaskImageFilterISS3ISS3ISS3_Superclass):
    r"""Proxy of C++ itkMaskImageFilterISS3ISS3ISS3 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterISS3ISS3ISS3
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterISS3ISS3ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterISS3ISS3ISS3 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_swigregister(itkMaskImageFilterISS3ISS3ISS3)
class itkMaskImageFilterISS3IUC3ISS3(itkMaskImageFilterISS3IUC3ISS3_Superclass):
    r"""Proxy of C++ itkMaskImageFilterISS3IUC3ISS3 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterISS3IUC3ISS3
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterISS3IUC3ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterISS3IUC3ISS3 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_swigregister(itkMaskImageFilterISS3IUC3ISS3)
class itkMaskImageFilterIUC2ISS2IUC2(itkMaskImageFilterIUC2ISS2IUC2_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIUC2ISS2IUC2 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIUC2ISS2IUC2
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIUC2ISS2IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIUC2ISS2IUC2 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_swigregister(itkMaskImageFilterIUC2ISS2IUC2)
class itkMaskImageFilterIUC2IUC2IUC2(itkMaskImageFilterIUC2IUC2IUC2_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIUC2IUC2IUC2 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIUC2IUC2IUC2
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIUC2IUC2IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIUC2IUC2IUC2 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_swigregister(itkMaskImageFilterIUC2IUC2IUC2)
class itkMaskImageFilterIUC3ISS3IUC3(itkMaskImageFilterIUC3ISS3IUC3_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIUC3ISS3IUC3 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIUC3ISS3IUC3
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIUC3ISS3IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIUC3ISS3IUC3 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_swigregister(itkMaskImageFilterIUC3ISS3IUC3)
class itkMaskImageFilterIUC3IUC3IUC3(itkMaskImageFilterIUC3IUC3IUC3_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIUC3IUC3IUC3 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIUC3IUC3IUC3
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIUC3IUC3IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIUC3IUC3IUC3 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_swigregister(itkMaskImageFilterIUC3IUC3IUC3)
class itkMaskImageFilterIVF22ISS2IVF22(itkMaskImageFilterIVF22ISS2IVF22_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIVF22ISS2IVF22 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF22ISS2IVF22
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIVF22ISS2IVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIVF22ISS2IVF22 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_swigregister(itkMaskImageFilterIVF22ISS2IVF22)
class itkMaskImageFilterIVF22IUC2IVF22(itkMaskImageFilterIVF22IUC2IVF22_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIVF22IUC2IVF22 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF22IUC2IVF22
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIVF22IUC2IVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIVF22IUC2IVF22 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_swigregister(itkMaskImageFilterIVF22IUC2IVF22)
class itkMaskImageFilterIVF23ISS3IVF23(itkMaskImageFilterIVF23ISS3IVF23_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIVF23ISS3IVF23 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF23ISS3IVF23
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIVF23ISS3IVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIVF23ISS3IVF23 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_swigregister(itkMaskImageFilterIVF23ISS3IVF23)
class itkMaskImageFilterIVF23IUC3IVF23(itkMaskImageFilterIVF23IUC3IVF23_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIVF23IUC3IVF23 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF23IUC3IVF23
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIVF23IUC3IVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIVF23IUC3IVF23 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_swigregister(itkMaskImageFilterIVF23IUC3IVF23)
class itkMaskImageFilterIVF32ISS2IVF32(itkMaskImageFilterIVF32ISS2IVF32_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIVF32ISS2IVF32 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF32ISS2IVF32
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIVF32ISS2IVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIVF32ISS2IVF32 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_swigregister(itkMaskImageFilterIVF32ISS2IVF32)
class itkMaskImageFilterIVF32IUC2IVF32(itkMaskImageFilterIVF32IUC2IVF32_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIVF32IUC2IVF32 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF32IUC2IVF32
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIVF32IUC2IVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIVF32IUC2IVF32 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_swigregister(itkMaskImageFilterIVF32IUC2IVF32)
class itkMaskImageFilterIVF33ISS3IVF33(itkMaskImageFilterIVF33ISS3IVF33_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIVF33ISS3IVF33 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF33ISS3IVF33
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIVF33ISS3IVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIVF33ISS3IVF33 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_swigregister(itkMaskImageFilterIVF33ISS3IVF33)
class itkMaskImageFilterIVF33IUC3IVF33(itkMaskImageFilterIVF33IUC3IVF33_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIVF33IUC3IVF33 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF33IUC3IVF33
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIVF33IUC3IVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIVF33IUC3IVF33 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_swigregister(itkMaskImageFilterIVF33IUC3IVF33)
class itkMaskImageFilterIVF42ISS2IVF42(itkMaskImageFilterIVF42ISS2IVF42_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIVF42ISS2IVF42 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF42ISS2IVF42
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIVF42ISS2IVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIVF42ISS2IVF42 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_swigregister(itkMaskImageFilterIVF42ISS2IVF42)
class itkMaskImageFilterIVF42IUC2IVF42(itkMaskImageFilterIVF42IUC2IVF42_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIVF42IUC2IVF42 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF42IUC2IVF42
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIVF42IUC2IVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIVF42IUC2IVF42 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_swigregister(itkMaskImageFilterIVF42IUC2IVF42)
class itkMaskImageFilterIVF43ISS3IVF43(itkMaskImageFilterIVF43ISS3IVF43_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIVF43ISS3IVF43 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF43ISS3IVF43
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIVF43ISS3IVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIVF43ISS3IVF43 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_swigregister(itkMaskImageFilterIVF43ISS3IVF43)
class itkMaskImageFilterIVF43IUC3IVF43(itkMaskImageFilterIVF43IUC3IVF43_Superclass):
    r"""Proxy of C++ itkMaskImageFilterIVF43IUC3IVF43 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_Clone)
    SetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_GetMaskImage)
    SetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_GetMaskingValue)
    BeforeThreadedGenerateData = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_BeforeThreadedGenerateData)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF43IUC3IVF43
    cast = _swig_new_static_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_cast)
    GetPointer = _swig_new_instance_method(_itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_GetPointer)

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

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

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

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

        Ex:

          itkMaskImageFilterIVF43IUC3IVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskImageFilterIVF43IUC3IVF43 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_swigregister(itkMaskImageFilterIVF43IUC3IVF43)

