# 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.


import collections

from sys import version_info as _version_info
if _version_info < (3, 7, 0):
    raise RuntimeError("Python 3.7 or later required")

from . import _ITKCommonPython


from . import _ITKImageIntensityPython



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__

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__)


if _swig_python_version_info[0:2] >= (3, 3):
    import collections.abc
else:
    import collections

import itk.stdcomplexPython
import itk.pyBasePython
import itk.itkRGBPixelPython
import itk.itkFixedArrayPython
import itk.itkCovariantVectorPython
import itk.itkVectorPython
import itk.vnl_vector_refPython
import itk.vnl_vectorPython
import itk.vnl_matrixPython
import itk.itkRGBAPixelPython
import itk.itkBinaryGeneratorImageFilterPython
import itk.itkImagePython
import itk.itkPointPython
import itk.itkMatrixPython
import itk.vnl_matrix_fixedPython
import itk.itkSizePython
import itk.itkSymmetricSecondRankTensorPython
import itk.itkIndexPython
import itk.itkOffsetPython
import itk.ITKCommonBasePython
import itk.itkImageRegionPython
import itk.itkInPlaceImageFilterBPython
import itk.itkImageToImageFilterBPython
import itk.itkPhasedArray3DSpecialCoordinatesImagePython
import itk.itkImageSourcePython
import itk.itkVectorImagePython
import itk.itkVariableLengthVectorPython
import itk.itkImageSourceCommonPython
import itk.itkImageToImageFilterCommonPython
import itk.itkSimpleDataObjectDecoratorPython
import itk.itkArrayPython
import itk.itkInPlaceImageFilterAPython
import itk.itkImageToImageFilterAPython

def itkMaskImageFilterICF2ISS2ICF2_New():
    return itkMaskImageFilterICF2ISS2ICF2.New()

class itkMaskImageFilterICF2ISS2ICF2(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICF2ISS2ICF2):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterICF2ISS2ICF2_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterICF2ISS2ICF2_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageSS2 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: stdcomplexF const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> stdcomplexF"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICF2ISS2ICF2

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterICF2ISS2ICF2

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterICF2ISS2ICF2 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICF2ISS2ICF2_swigregister(itkMaskImageFilterICF2ISS2ICF2)

def itkMaskImageFilterICF2IUC2ICF2_New():
    return itkMaskImageFilterICF2IUC2ICF2.New()

class itkMaskImageFilterICF2IUC2ICF2(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICF2IUC2ICF2):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterICF2IUC2ICF2_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterICF2IUC2ICF2_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageUC2 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: stdcomplexF const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> stdcomplexF"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICF2IUC2ICF2

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterICF2IUC2ICF2

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterICF2IUC2ICF2 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICF2IUC2ICF2_swigregister(itkMaskImageFilterICF2IUC2ICF2)

def itkMaskImageFilterICF3ISS3ICF3_New():
    return itkMaskImageFilterICF3ISS3ICF3.New()

class itkMaskImageFilterICF3ISS3ICF3(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICF3ISS3ICF3):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterICF3ISS3ICF3_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterICF3ISS3ICF3_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageSS3 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: stdcomplexF const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> stdcomplexF"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICF3ISS3ICF3

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterICF3ISS3ICF3

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterICF3ISS3ICF3 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICF3ISS3ICF3_swigregister(itkMaskImageFilterICF3ISS3ICF3)

def itkMaskImageFilterICF3IUC3ICF3_New():
    return itkMaskImageFilterICF3IUC3ICF3.New()

class itkMaskImageFilterICF3IUC3ICF3(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICF3IUC3ICF3):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterICF3IUC3ICF3_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterICF3IUC3ICF3_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageUC3 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: stdcomplexF const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> stdcomplexF"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICF3IUC3ICF3

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterICF3IUC3ICF3

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterICF3IUC3ICF3 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICF3IUC3ICF3_swigregister(itkMaskImageFilterICF3IUC3ICF3)

def itkMaskImageFilterICVF22ISS2ICVF22_New():
    return itkMaskImageFilterICVF22ISS2ICVF22.New()

class itkMaskImageFilterICVF22ISS2ICVF22(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICVF22ISS2ICVF22):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterICVF22ISS2ICVF22_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterICVF22ISS2ICVF22_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageSS2 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkCovariantVectorF2 const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkCovariantVectorF2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF22ISS2ICVF22

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterICVF22ISS2ICVF22

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterICVF22ISS2ICVF22 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF22ISS2ICVF22_swigregister(itkMaskImageFilterICVF22ISS2ICVF22)

def itkMaskImageFilterICVF22IUC2ICVF22_New():
    return itkMaskImageFilterICVF22IUC2ICVF22.New()

class itkMaskImageFilterICVF22IUC2ICVF22(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICVF22IUC2ICVF22):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterICVF22IUC2ICVF22_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterICVF22IUC2ICVF22_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageUC2 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkCovariantVectorF2 const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkCovariantVectorF2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF22IUC2ICVF22

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterICVF22IUC2ICVF22

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterICVF22IUC2ICVF22 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF22IUC2ICVF22_swigregister(itkMaskImageFilterICVF22IUC2ICVF22)

def itkMaskImageFilterICVF23ISS3ICVF23_New():
    return itkMaskImageFilterICVF23ISS3ICVF23.New()

class itkMaskImageFilterICVF23ISS3ICVF23(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICVF23ISS3ICVF23):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterICVF23ISS3ICVF23_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterICVF23ISS3ICVF23_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageSS3 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkCovariantVectorF2 const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkCovariantVectorF2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF23ISS3ICVF23

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterICVF23ISS3ICVF23

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterICVF23ISS3ICVF23 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF23ISS3ICVF23_swigregister(itkMaskImageFilterICVF23ISS3ICVF23)

def itkMaskImageFilterICVF23IUC3ICVF23_New():
    return itkMaskImageFilterICVF23IUC3ICVF23.New()

class itkMaskImageFilterICVF23IUC3ICVF23(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICVF23IUC3ICVF23):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterICVF23IUC3ICVF23_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterICVF23IUC3ICVF23_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageUC3 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkCovariantVectorF2 const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkCovariantVectorF2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF23IUC3ICVF23

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterICVF23IUC3ICVF23

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterICVF23IUC3ICVF23 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF23IUC3ICVF23_swigregister(itkMaskImageFilterICVF23IUC3ICVF23)

def itkMaskImageFilterICVF32ISS2ICVF32_New():
    return itkMaskImageFilterICVF32ISS2ICVF32.New()

class itkMaskImageFilterICVF32ISS2ICVF32(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICVF32ISS2ICVF32):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterICVF32ISS2ICVF32_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterICVF32ISS2ICVF32_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageSS2 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkCovariantVectorF3 const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkCovariantVectorF3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF32ISS2ICVF32

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterICVF32ISS2ICVF32

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterICVF32ISS2ICVF32 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF32ISS2ICVF32_swigregister(itkMaskImageFilterICVF32ISS2ICVF32)

def itkMaskImageFilterICVF32IUC2ICVF32_New():
    return itkMaskImageFilterICVF32IUC2ICVF32.New()

class itkMaskImageFilterICVF32IUC2ICVF32(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICVF32IUC2ICVF32):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterICVF32IUC2ICVF32_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterICVF32IUC2ICVF32_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageUC2 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkCovariantVectorF3 const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkCovariantVectorF3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF32IUC2ICVF32

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterICVF32IUC2ICVF32

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterICVF32IUC2ICVF32 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF32IUC2ICVF32_swigregister(itkMaskImageFilterICVF32IUC2ICVF32)

def itkMaskImageFilterICVF33ISS3ICVF33_New():
    return itkMaskImageFilterICVF33ISS3ICVF33.New()

class itkMaskImageFilterICVF33ISS3ICVF33(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICVF33ISS3ICVF33):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterICVF33ISS3ICVF33_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterICVF33ISS3ICVF33_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageSS3 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkCovariantVectorF3 const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkCovariantVectorF3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF33ISS3ICVF33

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterICVF33ISS3ICVF33

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterICVF33ISS3ICVF33 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF33ISS3ICVF33_swigregister(itkMaskImageFilterICVF33ISS3ICVF33)

def itkMaskImageFilterICVF33IUC3ICVF33_New():
    return itkMaskImageFilterICVF33IUC3ICVF33.New()

class itkMaskImageFilterICVF33IUC3ICVF33(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICVF33IUC3ICVF33):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterICVF33IUC3ICVF33_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterICVF33IUC3ICVF33_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageUC3 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkCovariantVectorF3 const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkCovariantVectorF3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF33IUC3ICVF33

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterICVF33IUC3ICVF33

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterICVF33IUC3ICVF33 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF33IUC3ICVF33_swigregister(itkMaskImageFilterICVF33IUC3ICVF33)

def itkMaskImageFilterICVF42ISS2ICVF42_New():
    return itkMaskImageFilterICVF42ISS2ICVF42.New()

class itkMaskImageFilterICVF42ISS2ICVF42(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICVF42ISS2ICVF42):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterICVF42ISS2ICVF42_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterICVF42ISS2ICVF42_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageSS2 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkCovariantVectorF4 const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkCovariantVectorF4"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF42ISS2ICVF42

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterICVF42ISS2ICVF42

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterICVF42ISS2ICVF42 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF42ISS2ICVF42_swigregister(itkMaskImageFilterICVF42ISS2ICVF42)

def itkMaskImageFilterICVF42IUC2ICVF42_New():
    return itkMaskImageFilterICVF42IUC2ICVF42.New()

class itkMaskImageFilterICVF42IUC2ICVF42(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICVF42IUC2ICVF42):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterICVF42IUC2ICVF42_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterICVF42IUC2ICVF42_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageUC2 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkCovariantVectorF4 const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkCovariantVectorF4"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF42IUC2ICVF42

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterICVF42IUC2ICVF42

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterICVF42IUC2ICVF42 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF42IUC2ICVF42_swigregister(itkMaskImageFilterICVF42IUC2ICVF42)

def itkMaskImageFilterICVF43ISS3ICVF43_New():
    return itkMaskImageFilterICVF43ISS3ICVF43.New()

class itkMaskImageFilterICVF43ISS3ICVF43(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICVF43ISS3ICVF43):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterICVF43ISS3ICVF43_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterICVF43ISS3ICVF43_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageSS3 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkCovariantVectorF4 const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkCovariantVectorF4"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF43ISS3ICVF43

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterICVF43ISS3ICVF43

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterICVF43ISS3ICVF43 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF43ISS3ICVF43_swigregister(itkMaskImageFilterICVF43ISS3ICVF43)

def itkMaskImageFilterICVF43IUC3ICVF43_New():
    return itkMaskImageFilterICVF43IUC3ICVF43.New()

class itkMaskImageFilterICVF43IUC3ICVF43(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICVF43IUC3ICVF43):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterICVF43IUC3ICVF43_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterICVF43IUC3ICVF43_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageUC3 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkCovariantVectorF4 const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkCovariantVectorF4"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterICVF43IUC3ICVF43

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterICVF43IUC3ICVF43

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterICVF43IUC3ICVF43 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterICVF43IUC3ICVF43_swigregister(itkMaskImageFilterICVF43IUC3ICVF43)

def itkMaskImageFilterIF2ISS2IF2_New():
    return itkMaskImageFilterIF2ISS2IF2.New()

class itkMaskImageFilterIF2ISS2IF2(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIF2ISS2IF2):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIF2ISS2IF2_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIF2ISS2IF2_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageSS2 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: float const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> float const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIF2ISS2IF2

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIF2ISS2IF2

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterIF2ISS2IF2 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIF2ISS2IF2_swigregister(itkMaskImageFilterIF2ISS2IF2)

def itkMaskImageFilterIF2IUC2IF2_New():
    return itkMaskImageFilterIF2IUC2IF2.New()

class itkMaskImageFilterIF2IUC2IF2(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIF2IUC2IF2):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIF2IUC2IF2_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIF2IUC2IF2_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageUC2 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: float const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> float const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIF2IUC2IF2

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIF2IUC2IF2

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterIF2IUC2IF2 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIF2IUC2IF2_swigregister(itkMaskImageFilterIF2IUC2IF2)

def itkMaskImageFilterIF3ISS3IF3_New():
    return itkMaskImageFilterIF3ISS3IF3.New()

class itkMaskImageFilterIF3ISS3IF3(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIF3ISS3IF3):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIF3ISS3IF3_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIF3ISS3IF3_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageSS3 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: float const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> float const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIF3ISS3IF3

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIF3ISS3IF3

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterIF3ISS3IF3 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIF3ISS3IF3_swigregister(itkMaskImageFilterIF3ISS3IF3)

def itkMaskImageFilterIF3IUC3IF3_New():
    return itkMaskImageFilterIF3IUC3IF3.New()

class itkMaskImageFilterIF3IUC3IF3(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIF3IUC3IF3):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIF3IUC3IF3_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIF3IUC3IF3_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageUC3 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: float const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> float const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIF3IUC3IF3

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIF3IUC3IF3

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterIF3IUC3IF3 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIF3IUC3IF3_swigregister(itkMaskImageFilterIF3IUC3IF3)

def itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_New():
    return itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2.New()

class itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIRGBAUC2ISS2IRGBAUC2):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageSS2 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkRGBAPixelUC const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkRGBAPixelUC"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2_swigregister(itkMaskImageFilterIRGBAUC2ISS2IRGBAUC2)

def itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_New():
    return itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2.New()

class itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIRGBAUC2IUC2IRGBAUC2):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageUC2 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkRGBAPixelUC const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkRGBAPixelUC"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2_swigregister(itkMaskImageFilterIRGBAUC2IUC2IRGBAUC2)

def itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_New():
    return itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3.New()

class itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIRGBAUC3ISS3IRGBAUC3):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageSS3 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkRGBAPixelUC const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkRGBAPixelUC"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3_swigregister(itkMaskImageFilterIRGBAUC3ISS3IRGBAUC3)

def itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_New():
    return itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3.New()

class itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIRGBAUC3IUC3IRGBAUC3):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageUC3 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkRGBAPixelUC const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkRGBAPixelUC"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3_swigregister(itkMaskImageFilterIRGBAUC3IUC3IRGBAUC3)

def itkMaskImageFilterIRGBUC2ISS2IRGBUC2_New():
    return itkMaskImageFilterIRGBUC2ISS2IRGBUC2.New()

class itkMaskImageFilterIRGBUC2ISS2IRGBUC2(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIRGBUC2ISS2IRGBUC2):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageSS2 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkRGBPixelUC const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkRGBPixelUC"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIRGBUC2ISS2IRGBUC2

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIRGBUC2ISS2IRGBUC2

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterIRGBUC2ISS2IRGBUC2 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2ISS2IRGBUC2_swigregister(itkMaskImageFilterIRGBUC2ISS2IRGBUC2)

def itkMaskImageFilterIRGBUC2IUC2IRGBUC2_New():
    return itkMaskImageFilterIRGBUC2IUC2IRGBUC2.New()

class itkMaskImageFilterIRGBUC2IUC2IRGBUC2(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIRGBUC2IUC2IRGBUC2):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageUC2 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkRGBPixelUC const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkRGBPixelUC"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIRGBUC2IUC2IRGBUC2

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIRGBUC2IUC2IRGBUC2

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterIRGBUC2IUC2IRGBUC2 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC2IUC2IRGBUC2_swigregister(itkMaskImageFilterIRGBUC2IUC2IRGBUC2)

def itkMaskImageFilterIRGBUC3ISS3IRGBUC3_New():
    return itkMaskImageFilterIRGBUC3ISS3IRGBUC3.New()

class itkMaskImageFilterIRGBUC3ISS3IRGBUC3(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIRGBUC3ISS3IRGBUC3):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageSS3 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkRGBPixelUC const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkRGBPixelUC"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIRGBUC3ISS3IRGBUC3

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIRGBUC3ISS3IRGBUC3

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterIRGBUC3ISS3IRGBUC3 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3ISS3IRGBUC3_swigregister(itkMaskImageFilterIRGBUC3ISS3IRGBUC3)

def itkMaskImageFilterIRGBUC3IUC3IRGBUC3_New():
    return itkMaskImageFilterIRGBUC3IUC3IRGBUC3.New()

class itkMaskImageFilterIRGBUC3IUC3IRGBUC3(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIRGBUC3IUC3IRGBUC3):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageUC3 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkRGBPixelUC const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkRGBPixelUC"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIRGBUC3IUC3IRGBUC3

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIRGBUC3IUC3IRGBUC3

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterIRGBUC3IUC3IRGBUC3 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIRGBUC3IUC3IRGBUC3_swigregister(itkMaskImageFilterIRGBUC3IUC3IRGBUC3)

def itkMaskImageFilterISS2ISS2ISS2_New():
    return itkMaskImageFilterISS2ISS2ISS2.New()

class itkMaskImageFilterISS2ISS2ISS2(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterISS2ISS2ISS2):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterISS2ISS2ISS2_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterISS2ISS2ISS2_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageSS2 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterISS2ISS2ISS2

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterISS2ISS2ISS2

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterISS2ISS2ISS2 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterISS2ISS2ISS2_swigregister(itkMaskImageFilterISS2ISS2ISS2)

def itkMaskImageFilterISS2IUC2ISS2_New():
    return itkMaskImageFilterISS2IUC2ISS2.New()

class itkMaskImageFilterISS2IUC2ISS2(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterISS2IUC2ISS2):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterISS2IUC2ISS2_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterISS2IUC2ISS2_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageUC2 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterISS2IUC2ISS2

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterISS2IUC2ISS2

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterISS2IUC2ISS2 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterISS2IUC2ISS2_swigregister(itkMaskImageFilterISS2IUC2ISS2)

def itkMaskImageFilterISS3ISS3ISS3_New():
    return itkMaskImageFilterISS3ISS3ISS3.New()

class itkMaskImageFilterISS3ISS3ISS3(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterISS3ISS3ISS3):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterISS3ISS3ISS3_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterISS3ISS3ISS3_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageSS3 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterISS3ISS3ISS3

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterISS3ISS3ISS3

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterISS3ISS3ISS3 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterISS3ISS3ISS3_swigregister(itkMaskImageFilterISS3ISS3ISS3)

def itkMaskImageFilterISS3IUC3ISS3_New():
    return itkMaskImageFilterISS3IUC3ISS3.New()

class itkMaskImageFilterISS3IUC3ISS3(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterISS3IUC3ISS3):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterISS3IUC3ISS3_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterISS3IUC3ISS3_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageUC3 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterISS3IUC3ISS3

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterISS3IUC3ISS3

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterISS3IUC3ISS3 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterISS3IUC3ISS3_swigregister(itkMaskImageFilterISS3IUC3ISS3)

def itkMaskImageFilterIUC2ISS2IUC2_New():
    return itkMaskImageFilterIUC2ISS2IUC2.New()

class itkMaskImageFilterIUC2ISS2IUC2(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIUC2ISS2IUC2):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIUC2ISS2IUC2_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIUC2ISS2IUC2_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageSS2 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIUC2ISS2IUC2

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIUC2ISS2IUC2

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterIUC2ISS2IUC2 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIUC2ISS2IUC2_swigregister(itkMaskImageFilterIUC2ISS2IUC2)

def itkMaskImageFilterIUC2IUC2IUC2_New():
    return itkMaskImageFilterIUC2IUC2IUC2.New()

class itkMaskImageFilterIUC2IUC2IUC2(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIUC2IUC2IUC2):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIUC2IUC2IUC2_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIUC2IUC2IUC2_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageUC2 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIUC2IUC2IUC2

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIUC2IUC2IUC2

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterIUC2IUC2IUC2 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIUC2IUC2IUC2_swigregister(itkMaskImageFilterIUC2IUC2IUC2)

def itkMaskImageFilterIUC3ISS3IUC3_New():
    return itkMaskImageFilterIUC3ISS3IUC3.New()

class itkMaskImageFilterIUC3ISS3IUC3(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIUC3ISS3IUC3):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIUC3ISS3IUC3_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIUC3ISS3IUC3_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageSS3 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIUC3ISS3IUC3

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIUC3ISS3IUC3

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterIUC3ISS3IUC3 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIUC3ISS3IUC3_swigregister(itkMaskImageFilterIUC3ISS3IUC3)

def itkMaskImageFilterIUC3IUC3IUC3_New():
    return itkMaskImageFilterIUC3IUC3IUC3.New()

class itkMaskImageFilterIUC3IUC3IUC3(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIUC3IUC3IUC3):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIUC3IUC3IUC3_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIUC3IUC3IUC3_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageUC3 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIUC3IUC3IUC3

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIUC3IUC3IUC3

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterIUC3IUC3IUC3 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIUC3IUC3IUC3_swigregister(itkMaskImageFilterIUC3IUC3IUC3)

def itkMaskImageFilterIVF22ISS2IVF22_New():
    return itkMaskImageFilterIVF22ISS2IVF22.New()

class itkMaskImageFilterIVF22ISS2IVF22(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIVF22ISS2IVF22):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIVF22ISS2IVF22_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIVF22ISS2IVF22_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageSS2 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkVectorF2 const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkVectorF2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF22ISS2IVF22

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIVF22ISS2IVF22

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterIVF22ISS2IVF22 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF22ISS2IVF22_swigregister(itkMaskImageFilterIVF22ISS2IVF22)

def itkMaskImageFilterIVF22IUC2IVF22_New():
    return itkMaskImageFilterIVF22IUC2IVF22.New()

class itkMaskImageFilterIVF22IUC2IVF22(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIVF22IUC2IVF22):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIVF22IUC2IVF22_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIVF22IUC2IVF22_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageUC2 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkVectorF2 const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkVectorF2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF22IUC2IVF22

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIVF22IUC2IVF22

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterIVF22IUC2IVF22 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF22IUC2IVF22_swigregister(itkMaskImageFilterIVF22IUC2IVF22)

def itkMaskImageFilterIVF23ISS3IVF23_New():
    return itkMaskImageFilterIVF23ISS3IVF23.New()

class itkMaskImageFilterIVF23ISS3IVF23(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIVF23ISS3IVF23):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIVF23ISS3IVF23_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIVF23ISS3IVF23_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageSS3 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkVectorF2 const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkVectorF2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF23ISS3IVF23

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIVF23ISS3IVF23

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterIVF23ISS3IVF23 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF23ISS3IVF23_swigregister(itkMaskImageFilterIVF23ISS3IVF23)

def itkMaskImageFilterIVF23IUC3IVF23_New():
    return itkMaskImageFilterIVF23IUC3IVF23.New()

class itkMaskImageFilterIVF23IUC3IVF23(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIVF23IUC3IVF23):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIVF23IUC3IVF23_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIVF23IUC3IVF23_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageUC3 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkVectorF2 const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkVectorF2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF23IUC3IVF23

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIVF23IUC3IVF23

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterIVF23IUC3IVF23 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF23IUC3IVF23_swigregister(itkMaskImageFilterIVF23IUC3IVF23)

def itkMaskImageFilterIVF32ISS2IVF32_New():
    return itkMaskImageFilterIVF32ISS2IVF32.New()

class itkMaskImageFilterIVF32ISS2IVF32(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIVF32ISS2IVF32):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIVF32ISS2IVF32_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIVF32ISS2IVF32_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageSS2 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkVectorF3 const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkVectorF3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF32ISS2IVF32

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIVF32ISS2IVF32

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterIVF32ISS2IVF32 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF32ISS2IVF32_swigregister(itkMaskImageFilterIVF32ISS2IVF32)

def itkMaskImageFilterIVF32IUC2IVF32_New():
    return itkMaskImageFilterIVF32IUC2IVF32.New()

class itkMaskImageFilterIVF32IUC2IVF32(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIVF32IUC2IVF32):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIVF32IUC2IVF32_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIVF32IUC2IVF32_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageUC2 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkVectorF3 const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkVectorF3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF32IUC2IVF32

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIVF32IUC2IVF32

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterIVF32IUC2IVF32 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF32IUC2IVF32_swigregister(itkMaskImageFilterIVF32IUC2IVF32)

def itkMaskImageFilterIVF33ISS3IVF33_New():
    return itkMaskImageFilterIVF33ISS3IVF33.New()

class itkMaskImageFilterIVF33ISS3IVF33(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIVF33ISS3IVF33):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIVF33ISS3IVF33_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIVF33ISS3IVF33_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageSS3 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkVectorF3 const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkVectorF3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF33ISS3IVF33

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIVF33ISS3IVF33

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterIVF33ISS3IVF33 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF33ISS3IVF33_swigregister(itkMaskImageFilterIVF33ISS3IVF33)

def itkMaskImageFilterIVF33IUC3IVF33_New():
    return itkMaskImageFilterIVF33IUC3IVF33.New()

class itkMaskImageFilterIVF33IUC3IVF33(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIVF33IUC3IVF33):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIVF33IUC3IVF33_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIVF33IUC3IVF33_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageUC3 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkVectorF3 const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkVectorF3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF33IUC3IVF33

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIVF33IUC3IVF33

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterIVF33IUC3IVF33 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF33IUC3IVF33_swigregister(itkMaskImageFilterIVF33IUC3IVF33)

def itkMaskImageFilterIVF42ISS2IVF42_New():
    return itkMaskImageFilterIVF42ISS2IVF42.New()

class itkMaskImageFilterIVF42ISS2IVF42(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIVF42ISS2IVF42):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIVF42ISS2IVF42_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIVF42ISS2IVF42_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageSS2 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkVectorF4 const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkVectorF4"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF42ISS2IVF42

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIVF42ISS2IVF42

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterIVF42ISS2IVF42 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF42ISS2IVF42_swigregister(itkMaskImageFilterIVF42ISS2IVF42)

def itkMaskImageFilterIVF42IUC2IVF42_New():
    return itkMaskImageFilterIVF42IUC2IVF42.New()

class itkMaskImageFilterIVF42IUC2IVF42(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIVF42IUC2IVF42):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIVF42IUC2IVF42_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIVF42IUC2IVF42_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageUC2 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC2"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkVectorF4 const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkVectorF4"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF42IUC2IVF42

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIVF42IUC2IVF42

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterIVF42IUC2IVF42 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF42IUC2IVF42_swigregister(itkMaskImageFilterIVF42IUC2IVF42)

def itkMaskImageFilterIVF43ISS3IVF43_New():
    return itkMaskImageFilterIVF43ISS3IVF43.New()

class itkMaskImageFilterIVF43ISS3IVF43(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIVF43ISS3IVF43):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIVF43ISS3IVF43_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIVF43ISS3IVF43_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageSS3 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkVectorF4 const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkVectorF4"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: short const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF43ISS3IVF43

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIVF43ISS3IVF43

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskImageFilterIVF43ISS3IVF43 in _itkMaskImageFilterPython:
_itkMaskImageFilterPython.itkMaskImageFilterIVF43ISS3IVF43_swigregister(itkMaskImageFilterIVF43ISS3IVF43)

def itkMaskImageFilterIVF43IUC3IVF43_New():
    return itkMaskImageFilterIVF43IUC3IVF43.New()

class itkMaskImageFilterIVF43IUC3IVF43(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIVF43IUC3IVF43):
    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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMaskImageFilterIVF43IUC3IVF43_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskImageFilterIVF43IUC3IVF43_Pointer"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_Clone(self)

    def SetMaskImage(self, maskImage):
        r"""
        SetMaskImage(self, maskImage)

        Parameters
        ----------
        maskImage: itkImageUC3 const *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC3"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_GetMaskImage(self)

    def SetOutsideValue(self, outsideValue):
        r"""
        SetOutsideValue(self, outsideValue)

        Parameters
        ----------
        outsideValue: itkVectorF4 const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkVectorF4"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_GetOutsideValue(self)

    def SetMaskingValue(self, maskingValue):
        r"""
        SetMaskingValue(self, maskingValue)

        Parameters
        ----------
        maskingValue: unsigned char const &

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_GetMaskingValue(self)
    MaskEqualityComparableCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskImageFilterPython.delete_itkMaskImageFilterIVF43IUC3IVF43

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMaskImageFilterIVF43IUC3IVF43

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMaskImageFilterPython.itkMaskImageFilterIVF43IUC3IVF43_cast(obj)

    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__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


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

from itk.support import helpers
import itk.support.types as itkt
from typing import Sequence, Tuple, Union

@helpers.accept_array_like_xarray_torch
def mask_image_filter(*args: itkt.ImageLike,  mask_image: itkt.Image=..., outside_value: Sequence[float]=..., masking_value: int=..., constant1: Sequence[float]=..., constant2: int=..., constant: int=...,**kwargs)-> itkt.ImageSourceReturn:
    """Functional interface for MaskImageFilter"""
    import itk

    kwarg_typehints = { 'mask_image':mask_image,'outside_value':outside_value,'masking_value':masking_value,'constant1':constant1,'constant2':constant2,'constant':constant }
    specified_kwarg_typehints = { k:v for (k,v) in kwarg_typehints.items() if kwarg_typehints[k] is not ... }
    kwargs.update(specified_kwarg_typehints)


    instance = itk.MaskImageFilter.New(*args, **kwargs)

    return instance.__internal_call__()

def mask_image_filter_init_docstring():
    import itk
    from itk.support import template_class

    filter_class = itk.ITKImageIntensity.MaskImageFilter
    mask_image_filter.process_object = filter_class
    is_template = isinstance(filter_class, template_class.itkTemplate)
    if is_template:
        filter_object = filter_class.values()[0]
    else:
        filter_object = filter_class

    mask_image_filter.__doc__ = filter_object.__doc__



