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

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

def itkMaskNegatedImageFilterICF2ISS2ICF2_New():
    return itkMaskNegatedImageFilterICF2ISS2ICF2.New()

class itkMaskNegatedImageFilterICF2ISS2ICF2(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICF2ISS2ICF2):
    r"""Proxy of C++ itkMaskNegatedImageFilterICF2ISS2ICF2 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterICF2ISS2ICF2_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterICF2ISS2ICF2_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> stdcomplexF"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICF2ISS2ICF2

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICF2ISS2ICF2.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterICF2ISS2ICF2.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterICF2ISS2ICF2.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterICF2ISS2ICF2 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_swigregister(itkMaskNegatedImageFilterICF2ISS2ICF2)

def itkMaskNegatedImageFilterICF2IUC2ICF2_New():
    return itkMaskNegatedImageFilterICF2IUC2ICF2.New()

class itkMaskNegatedImageFilterICF2IUC2ICF2(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICF2IUC2ICF2):
    r"""Proxy of C++ itkMaskNegatedImageFilterICF2IUC2ICF2 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterICF2IUC2ICF2_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterICF2IUC2ICF2_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> stdcomplexF"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICF2IUC2ICF2

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICF2IUC2ICF2.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterICF2IUC2ICF2.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterICF2IUC2ICF2.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterICF2IUC2ICF2 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_swigregister(itkMaskNegatedImageFilterICF2IUC2ICF2)

def itkMaskNegatedImageFilterICF3ISS3ICF3_New():
    return itkMaskNegatedImageFilterICF3ISS3ICF3.New()

class itkMaskNegatedImageFilterICF3ISS3ICF3(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICF3ISS3ICF3):
    r"""Proxy of C++ itkMaskNegatedImageFilterICF3ISS3ICF3 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterICF3ISS3ICF3_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterICF3ISS3ICF3_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> stdcomplexF"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICF3ISS3ICF3

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICF3ISS3ICF3.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterICF3ISS3ICF3.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterICF3ISS3ICF3.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterICF3ISS3ICF3 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_swigregister(itkMaskNegatedImageFilterICF3ISS3ICF3)

def itkMaskNegatedImageFilterICF3IUC3ICF3_New():
    return itkMaskNegatedImageFilterICF3IUC3ICF3.New()

class itkMaskNegatedImageFilterICF3IUC3ICF3(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICF3IUC3ICF3):
    r"""Proxy of C++ itkMaskNegatedImageFilterICF3IUC3ICF3 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterICF3IUC3ICF3_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterICF3IUC3ICF3_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> stdcomplexF"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICF3IUC3ICF3

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICF3IUC3ICF3.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterICF3IUC3ICF3.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterICF3IUC3ICF3.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterICF3IUC3ICF3 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_swigregister(itkMaskNegatedImageFilterICF3IUC3ICF3)

def itkMaskNegatedImageFilterICVF22ISS2ICVF22_New():
    return itkMaskNegatedImageFilterICVF22ISS2ICVF22.New()

class itkMaskNegatedImageFilterICVF22ISS2ICVF22(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICVF22ISS2ICVF22):
    r"""Proxy of C++ itkMaskNegatedImageFilterICVF22ISS2ICVF22 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterICVF22ISS2ICVF22_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterICVF22ISS2ICVF22_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkCovariantVectorF2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF22ISS2ICVF22

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICVF22ISS2ICVF22.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterICVF22ISS2ICVF22.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterICVF22ISS2ICVF22.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterICVF22ISS2ICVF22 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_swigregister(itkMaskNegatedImageFilterICVF22ISS2ICVF22)

def itkMaskNegatedImageFilterICVF22IUC2ICVF22_New():
    return itkMaskNegatedImageFilterICVF22IUC2ICVF22.New()

class itkMaskNegatedImageFilterICVF22IUC2ICVF22(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICVF22IUC2ICVF22):
    r"""Proxy of C++ itkMaskNegatedImageFilterICVF22IUC2ICVF22 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterICVF22IUC2ICVF22_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterICVF22IUC2ICVF22_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkCovariantVectorF2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF22IUC2ICVF22

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICVF22IUC2ICVF22.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterICVF22IUC2ICVF22.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterICVF22IUC2ICVF22.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterICVF22IUC2ICVF22 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_swigregister(itkMaskNegatedImageFilterICVF22IUC2ICVF22)

def itkMaskNegatedImageFilterICVF23ISS3ICVF23_New():
    return itkMaskNegatedImageFilterICVF23ISS3ICVF23.New()

class itkMaskNegatedImageFilterICVF23ISS3ICVF23(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICVF23ISS3ICVF23):
    r"""Proxy of C++ itkMaskNegatedImageFilterICVF23ISS3ICVF23 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterICVF23ISS3ICVF23_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterICVF23ISS3ICVF23_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkCovariantVectorF2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF23ISS3ICVF23

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICVF23ISS3ICVF23.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterICVF23ISS3ICVF23.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterICVF23ISS3ICVF23.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterICVF23ISS3ICVF23 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_swigregister(itkMaskNegatedImageFilterICVF23ISS3ICVF23)

def itkMaskNegatedImageFilterICVF23IUC3ICVF23_New():
    return itkMaskNegatedImageFilterICVF23IUC3ICVF23.New()

class itkMaskNegatedImageFilterICVF23IUC3ICVF23(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICVF23IUC3ICVF23):
    r"""Proxy of C++ itkMaskNegatedImageFilterICVF23IUC3ICVF23 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterICVF23IUC3ICVF23_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterICVF23IUC3ICVF23_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkCovariantVectorF2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF23IUC3ICVF23

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICVF23IUC3ICVF23.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterICVF23IUC3ICVF23.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterICVF23IUC3ICVF23.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterICVF23IUC3ICVF23 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_swigregister(itkMaskNegatedImageFilterICVF23IUC3ICVF23)

def itkMaskNegatedImageFilterICVF32ISS2ICVF32_New():
    return itkMaskNegatedImageFilterICVF32ISS2ICVF32.New()

class itkMaskNegatedImageFilterICVF32ISS2ICVF32(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICVF32ISS2ICVF32):
    r"""Proxy of C++ itkMaskNegatedImageFilterICVF32ISS2ICVF32 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterICVF32ISS2ICVF32_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterICVF32ISS2ICVF32_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkCovariantVectorF3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF32ISS2ICVF32

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICVF32ISS2ICVF32.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterICVF32ISS2ICVF32.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterICVF32ISS2ICVF32.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterICVF32ISS2ICVF32 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_swigregister(itkMaskNegatedImageFilterICVF32ISS2ICVF32)

def itkMaskNegatedImageFilterICVF32IUC2ICVF32_New():
    return itkMaskNegatedImageFilterICVF32IUC2ICVF32.New()

class itkMaskNegatedImageFilterICVF32IUC2ICVF32(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICVF32IUC2ICVF32):
    r"""Proxy of C++ itkMaskNegatedImageFilterICVF32IUC2ICVF32 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterICVF32IUC2ICVF32_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterICVF32IUC2ICVF32_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkCovariantVectorF3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF32IUC2ICVF32

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICVF32IUC2ICVF32.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterICVF32IUC2ICVF32.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterICVF32IUC2ICVF32.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterICVF32IUC2ICVF32 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_swigregister(itkMaskNegatedImageFilterICVF32IUC2ICVF32)

def itkMaskNegatedImageFilterICVF33ISS3ICVF33_New():
    return itkMaskNegatedImageFilterICVF33ISS3ICVF33.New()

class itkMaskNegatedImageFilterICVF33ISS3ICVF33(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICVF33ISS3ICVF33):
    r"""Proxy of C++ itkMaskNegatedImageFilterICVF33ISS3ICVF33 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterICVF33ISS3ICVF33_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterICVF33ISS3ICVF33_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkCovariantVectorF3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF33ISS3ICVF33

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICVF33ISS3ICVF33.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterICVF33ISS3ICVF33.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterICVF33ISS3ICVF33.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterICVF33ISS3ICVF33 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_swigregister(itkMaskNegatedImageFilterICVF33ISS3ICVF33)

def itkMaskNegatedImageFilterICVF33IUC3ICVF33_New():
    return itkMaskNegatedImageFilterICVF33IUC3ICVF33.New()

class itkMaskNegatedImageFilterICVF33IUC3ICVF33(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICVF33IUC3ICVF33):
    r"""Proxy of C++ itkMaskNegatedImageFilterICVF33IUC3ICVF33 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterICVF33IUC3ICVF33_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterICVF33IUC3ICVF33_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkCovariantVectorF3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF33IUC3ICVF33

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICVF33IUC3ICVF33.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterICVF33IUC3ICVF33.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterICVF33IUC3ICVF33.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterICVF33IUC3ICVF33 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_swigregister(itkMaskNegatedImageFilterICVF33IUC3ICVF33)

def itkMaskNegatedImageFilterICVF42ISS2ICVF42_New():
    return itkMaskNegatedImageFilterICVF42ISS2ICVF42.New()

class itkMaskNegatedImageFilterICVF42ISS2ICVF42(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICVF42ISS2ICVF42):
    r"""Proxy of C++ itkMaskNegatedImageFilterICVF42ISS2ICVF42 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterICVF42ISS2ICVF42_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterICVF42ISS2ICVF42_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkCovariantVectorF4"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF42ISS2ICVF42

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICVF42ISS2ICVF42.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterICVF42ISS2ICVF42.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterICVF42ISS2ICVF42.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterICVF42ISS2ICVF42 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_swigregister(itkMaskNegatedImageFilterICVF42ISS2ICVF42)

def itkMaskNegatedImageFilterICVF42IUC2ICVF42_New():
    return itkMaskNegatedImageFilterICVF42IUC2ICVF42.New()

class itkMaskNegatedImageFilterICVF42IUC2ICVF42(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICVF42IUC2ICVF42):
    r"""Proxy of C++ itkMaskNegatedImageFilterICVF42IUC2ICVF42 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterICVF42IUC2ICVF42_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterICVF42IUC2ICVF42_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkCovariantVectorF4"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF42IUC2ICVF42

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICVF42IUC2ICVF42.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterICVF42IUC2ICVF42.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterICVF42IUC2ICVF42.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterICVF42IUC2ICVF42 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_swigregister(itkMaskNegatedImageFilterICVF42IUC2ICVF42)

def itkMaskNegatedImageFilterICVF43ISS3ICVF43_New():
    return itkMaskNegatedImageFilterICVF43ISS3ICVF43.New()

class itkMaskNegatedImageFilterICVF43ISS3ICVF43(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICVF43ISS3ICVF43):
    r"""Proxy of C++ itkMaskNegatedImageFilterICVF43ISS3ICVF43 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterICVF43ISS3ICVF43_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterICVF43ISS3ICVF43_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkCovariantVectorF4"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF43ISS3ICVF43

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICVF43ISS3ICVF43.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterICVF43ISS3ICVF43.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterICVF43ISS3ICVF43.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterICVF43ISS3ICVF43 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_swigregister(itkMaskNegatedImageFilterICVF43ISS3ICVF43)

def itkMaskNegatedImageFilterICVF43IUC3ICVF43_New():
    return itkMaskNegatedImageFilterICVF43IUC3ICVF43.New()

class itkMaskNegatedImageFilterICVF43IUC3ICVF43(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterICVF43IUC3ICVF43):
    r"""Proxy of C++ itkMaskNegatedImageFilterICVF43IUC3ICVF43 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterICVF43IUC3ICVF43_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterICVF43IUC3ICVF43_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkCovariantVectorF4"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF43IUC3ICVF43

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICVF43IUC3ICVF43.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterICVF43IUC3ICVF43.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterICVF43IUC3ICVF43.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterICVF43IUC3ICVF43 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_swigregister(itkMaskNegatedImageFilterICVF43IUC3ICVF43)

def itkMaskNegatedImageFilterIF2ISS2IF2_New():
    return itkMaskNegatedImageFilterIF2ISS2IF2.New()

class itkMaskNegatedImageFilterIF2ISS2IF2(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIF2ISS2IF2):
    r"""Proxy of C++ itkMaskNegatedImageFilterIF2ISS2IF2 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIF2ISS2IF2_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIF2ISS2IF2_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> float const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIF2ISS2IF2

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIF2ISS2IF2.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIF2ISS2IF2.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIF2ISS2IF2.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIF2ISS2IF2 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_swigregister(itkMaskNegatedImageFilterIF2ISS2IF2)

def itkMaskNegatedImageFilterIF2IUC2IF2_New():
    return itkMaskNegatedImageFilterIF2IUC2IF2.New()

class itkMaskNegatedImageFilterIF2IUC2IF2(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIF2IUC2IF2):
    r"""Proxy of C++ itkMaskNegatedImageFilterIF2IUC2IF2 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIF2IUC2IF2_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIF2IUC2IF2_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> float const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIF2IUC2IF2

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIF2IUC2IF2.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIF2IUC2IF2.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIF2IUC2IF2.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIF2IUC2IF2 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_swigregister(itkMaskNegatedImageFilterIF2IUC2IF2)

def itkMaskNegatedImageFilterIF3ISS3IF3_New():
    return itkMaskNegatedImageFilterIF3ISS3IF3.New()

class itkMaskNegatedImageFilterIF3ISS3IF3(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIF3ISS3IF3):
    r"""Proxy of C++ itkMaskNegatedImageFilterIF3ISS3IF3 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIF3ISS3IF3_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIF3ISS3IF3_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> float const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIF3ISS3IF3

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIF3ISS3IF3.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIF3ISS3IF3.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIF3ISS3IF3.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIF3ISS3IF3 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_swigregister(itkMaskNegatedImageFilterIF3ISS3IF3)

def itkMaskNegatedImageFilterIF3IUC3IF3_New():
    return itkMaskNegatedImageFilterIF3IUC3IF3.New()

class itkMaskNegatedImageFilterIF3IUC3IF3(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIF3IUC3IF3):
    r"""Proxy of C++ itkMaskNegatedImageFilterIF3IUC3IF3 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIF3IUC3IF3_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIF3IUC3IF3_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> float const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIF3IUC3IF3

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIF3IUC3IF3.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIF3IUC3IF3.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIF3IUC3IF3.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIF3IUC3IF3 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_swigregister(itkMaskNegatedImageFilterIF3IUC3IF3)

def itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_New():
    return itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2.New()

class itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIRGBAUC2ISS2IRGBAUC2):
    r"""Proxy of C++ itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkRGBAPixelUC"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_swigregister(itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2)

def itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_New():
    return itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2.New()

class itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIRGBAUC2IUC2IRGBAUC2):
    r"""Proxy of C++ itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkRGBAPixelUC"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_swigregister(itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2)

def itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_New():
    return itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3.New()

class itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIRGBAUC3ISS3IRGBAUC3):
    r"""Proxy of C++ itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkRGBAPixelUC"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_swigregister(itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3)

def itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_New():
    return itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3.New()

class itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIRGBAUC3IUC3IRGBAUC3):
    r"""Proxy of C++ itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkRGBAPixelUC"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_swigregister(itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3)

def itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_New():
    return itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2.New()

class itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIRGBUC2ISS2IRGBUC2):
    r"""Proxy of C++ itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkRGBPixelUC"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_swigregister(itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2)

def itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_New():
    return itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2.New()

class itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIRGBUC2IUC2IRGBUC2):
    r"""Proxy of C++ itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkRGBPixelUC"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_swigregister(itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2)

def itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_New():
    return itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3.New()

class itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIRGBUC3ISS3IRGBUC3):
    r"""Proxy of C++ itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkRGBPixelUC"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_swigregister(itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3)

def itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_New():
    return itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3.New()

class itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIRGBUC3IUC3IRGBUC3):
    r"""Proxy of C++ itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkRGBPixelUC"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_swigregister(itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3)

def itkMaskNegatedImageFilterISS2ISS2ISS2_New():
    return itkMaskNegatedImageFilterISS2ISS2ISS2.New()

class itkMaskNegatedImageFilterISS2ISS2ISS2(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterISS2ISS2ISS2):
    r"""Proxy of C++ itkMaskNegatedImageFilterISS2ISS2ISS2 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterISS2ISS2ISS2_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterISS2ISS2ISS2_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterISS2ISS2ISS2

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterISS2ISS2ISS2.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterISS2ISS2ISS2.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterISS2ISS2ISS2.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterISS2ISS2ISS2 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_swigregister(itkMaskNegatedImageFilterISS2ISS2ISS2)

def itkMaskNegatedImageFilterISS2IUC2ISS2_New():
    return itkMaskNegatedImageFilterISS2IUC2ISS2.New()

class itkMaskNegatedImageFilterISS2IUC2ISS2(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterISS2IUC2ISS2):
    r"""Proxy of C++ itkMaskNegatedImageFilterISS2IUC2ISS2 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterISS2IUC2ISS2_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterISS2IUC2ISS2_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterISS2IUC2ISS2

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterISS2IUC2ISS2.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterISS2IUC2ISS2.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterISS2IUC2ISS2.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterISS2IUC2ISS2 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_swigregister(itkMaskNegatedImageFilterISS2IUC2ISS2)

def itkMaskNegatedImageFilterISS3ISS3ISS3_New():
    return itkMaskNegatedImageFilterISS3ISS3ISS3.New()

class itkMaskNegatedImageFilterISS3ISS3ISS3(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterISS3ISS3ISS3):
    r"""Proxy of C++ itkMaskNegatedImageFilterISS3ISS3ISS3 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterISS3ISS3ISS3_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterISS3ISS3ISS3_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterISS3ISS3ISS3

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterISS3ISS3ISS3.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterISS3ISS3ISS3.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterISS3ISS3ISS3.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterISS3ISS3ISS3 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_swigregister(itkMaskNegatedImageFilterISS3ISS3ISS3)

def itkMaskNegatedImageFilterISS3IUC3ISS3_New():
    return itkMaskNegatedImageFilterISS3IUC3ISS3.New()

class itkMaskNegatedImageFilterISS3IUC3ISS3(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterISS3IUC3ISS3):
    r"""Proxy of C++ itkMaskNegatedImageFilterISS3IUC3ISS3 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterISS3IUC3ISS3_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterISS3IUC3ISS3_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterISS3IUC3ISS3

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterISS3IUC3ISS3.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterISS3IUC3ISS3.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterISS3IUC3ISS3.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterISS3IUC3ISS3 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_swigregister(itkMaskNegatedImageFilterISS3IUC3ISS3)

def itkMaskNegatedImageFilterIUC2ISS2IUC2_New():
    return itkMaskNegatedImageFilterIUC2ISS2IUC2.New()

class itkMaskNegatedImageFilterIUC2ISS2IUC2(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIUC2ISS2IUC2):
    r"""Proxy of C++ itkMaskNegatedImageFilterIUC2ISS2IUC2 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIUC2ISS2IUC2_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIUC2ISS2IUC2_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_SetOutsideValue(self, outsideValue)

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

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIUC2ISS2IUC2

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIUC2ISS2IUC2.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIUC2ISS2IUC2.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIUC2ISS2IUC2.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIUC2ISS2IUC2 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_swigregister(itkMaskNegatedImageFilterIUC2ISS2IUC2)

def itkMaskNegatedImageFilterIUC2IUC2IUC2_New():
    return itkMaskNegatedImageFilterIUC2IUC2IUC2.New()

class itkMaskNegatedImageFilterIUC2IUC2IUC2(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIUC2IUC2IUC2):
    r"""Proxy of C++ itkMaskNegatedImageFilterIUC2IUC2IUC2 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIUC2IUC2IUC2_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIUC2IUC2IUC2_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_SetOutsideValue(self, outsideValue)

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

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIUC2IUC2IUC2

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIUC2IUC2IUC2.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIUC2IUC2IUC2.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIUC2IUC2IUC2.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIUC2IUC2IUC2 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_swigregister(itkMaskNegatedImageFilterIUC2IUC2IUC2)

def itkMaskNegatedImageFilterIUC3ISS3IUC3_New():
    return itkMaskNegatedImageFilterIUC3ISS3IUC3.New()

class itkMaskNegatedImageFilterIUC3ISS3IUC3(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIUC3ISS3IUC3):
    r"""Proxy of C++ itkMaskNegatedImageFilterIUC3ISS3IUC3 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIUC3ISS3IUC3_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIUC3ISS3IUC3_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_SetOutsideValue(self, outsideValue)

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

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIUC3ISS3IUC3

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIUC3ISS3IUC3.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIUC3ISS3IUC3.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIUC3ISS3IUC3.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIUC3ISS3IUC3 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_swigregister(itkMaskNegatedImageFilterIUC3ISS3IUC3)

def itkMaskNegatedImageFilterIUC3IUC3IUC3_New():
    return itkMaskNegatedImageFilterIUC3IUC3IUC3.New()

class itkMaskNegatedImageFilterIUC3IUC3IUC3(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIUC3IUC3IUC3):
    r"""Proxy of C++ itkMaskNegatedImageFilterIUC3IUC3IUC3 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIUC3IUC3IUC3_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIUC3IUC3IUC3_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_SetOutsideValue(self, outsideValue)

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

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIUC3IUC3IUC3

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIUC3IUC3IUC3.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIUC3IUC3IUC3.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIUC3IUC3IUC3.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIUC3IUC3IUC3 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_swigregister(itkMaskNegatedImageFilterIUC3IUC3IUC3)

def itkMaskNegatedImageFilterIVF22ISS2IVF22_New():
    return itkMaskNegatedImageFilterIVF22ISS2IVF22.New()

class itkMaskNegatedImageFilterIVF22ISS2IVF22(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIVF22ISS2IVF22):
    r"""Proxy of C++ itkMaskNegatedImageFilterIVF22ISS2IVF22 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIVF22ISS2IVF22_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIVF22ISS2IVF22_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkVectorF2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF22ISS2IVF22

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIVF22ISS2IVF22.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIVF22ISS2IVF22.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIVF22ISS2IVF22.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIVF22ISS2IVF22 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_swigregister(itkMaskNegatedImageFilterIVF22ISS2IVF22)

def itkMaskNegatedImageFilterIVF22IUC2IVF22_New():
    return itkMaskNegatedImageFilterIVF22IUC2IVF22.New()

class itkMaskNegatedImageFilterIVF22IUC2IVF22(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIVF22IUC2IVF22):
    r"""Proxy of C++ itkMaskNegatedImageFilterIVF22IUC2IVF22 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIVF22IUC2IVF22_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIVF22IUC2IVF22_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkVectorF2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF22IUC2IVF22

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIVF22IUC2IVF22.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIVF22IUC2IVF22.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIVF22IUC2IVF22.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIVF22IUC2IVF22 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_swigregister(itkMaskNegatedImageFilterIVF22IUC2IVF22)

def itkMaskNegatedImageFilterIVF23ISS3IVF23_New():
    return itkMaskNegatedImageFilterIVF23ISS3IVF23.New()

class itkMaskNegatedImageFilterIVF23ISS3IVF23(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIVF23ISS3IVF23):
    r"""Proxy of C++ itkMaskNegatedImageFilterIVF23ISS3IVF23 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIVF23ISS3IVF23_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIVF23ISS3IVF23_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkVectorF2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF23ISS3IVF23

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIVF23ISS3IVF23.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIVF23ISS3IVF23.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIVF23ISS3IVF23.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIVF23ISS3IVF23 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_swigregister(itkMaskNegatedImageFilterIVF23ISS3IVF23)

def itkMaskNegatedImageFilterIVF23IUC3IVF23_New():
    return itkMaskNegatedImageFilterIVF23IUC3IVF23.New()

class itkMaskNegatedImageFilterIVF23IUC3IVF23(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIVF23IUC3IVF23):
    r"""Proxy of C++ itkMaskNegatedImageFilterIVF23IUC3IVF23 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIVF23IUC3IVF23_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIVF23IUC3IVF23_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkVectorF2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF23IUC3IVF23

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIVF23IUC3IVF23.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIVF23IUC3IVF23.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIVF23IUC3IVF23.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIVF23IUC3IVF23 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_swigregister(itkMaskNegatedImageFilterIVF23IUC3IVF23)

def itkMaskNegatedImageFilterIVF32ISS2IVF32_New():
    return itkMaskNegatedImageFilterIVF32ISS2IVF32.New()

class itkMaskNegatedImageFilterIVF32ISS2IVF32(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIVF32ISS2IVF32):
    r"""Proxy of C++ itkMaskNegatedImageFilterIVF32ISS2IVF32 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIVF32ISS2IVF32_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIVF32ISS2IVF32_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkVectorF3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF32ISS2IVF32

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIVF32ISS2IVF32.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIVF32ISS2IVF32.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIVF32ISS2IVF32.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIVF32ISS2IVF32 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_swigregister(itkMaskNegatedImageFilterIVF32ISS2IVF32)

def itkMaskNegatedImageFilterIVF32IUC2IVF32_New():
    return itkMaskNegatedImageFilterIVF32IUC2IVF32.New()

class itkMaskNegatedImageFilterIVF32IUC2IVF32(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIVF32IUC2IVF32):
    r"""Proxy of C++ itkMaskNegatedImageFilterIVF32IUC2IVF32 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIVF32IUC2IVF32_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIVF32IUC2IVF32_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkVectorF3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF32IUC2IVF32

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIVF32IUC2IVF32.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIVF32IUC2IVF32.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIVF32IUC2IVF32.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIVF32IUC2IVF32 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_swigregister(itkMaskNegatedImageFilterIVF32IUC2IVF32)

def itkMaskNegatedImageFilterIVF33ISS3IVF33_New():
    return itkMaskNegatedImageFilterIVF33ISS3IVF33.New()

class itkMaskNegatedImageFilterIVF33ISS3IVF33(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIVF33ISS3IVF33):
    r"""Proxy of C++ itkMaskNegatedImageFilterIVF33ISS3IVF33 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIVF33ISS3IVF33_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIVF33ISS3IVF33_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkVectorF3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF33ISS3IVF33

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIVF33ISS3IVF33.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIVF33ISS3IVF33.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIVF33ISS3IVF33.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIVF33ISS3IVF33 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_swigregister(itkMaskNegatedImageFilterIVF33ISS3IVF33)

def itkMaskNegatedImageFilterIVF33IUC3IVF33_New():
    return itkMaskNegatedImageFilterIVF33IUC3IVF33.New()

class itkMaskNegatedImageFilterIVF33IUC3IVF33(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIVF33IUC3IVF33):
    r"""Proxy of C++ itkMaskNegatedImageFilterIVF33IUC3IVF33 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIVF33IUC3IVF33_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIVF33IUC3IVF33_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_Clone(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkVectorF3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF33IUC3IVF33

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIVF33IUC3IVF33.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIVF33IUC3IVF33.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIVF33IUC3IVF33.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIVF33IUC3IVF33 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_swigregister(itkMaskNegatedImageFilterIVF33IUC3IVF33)

def itkMaskNegatedImageFilterIVF42ISS2IVF42_New():
    return itkMaskNegatedImageFilterIVF42ISS2IVF42.New()

class itkMaskNegatedImageFilterIVF42ISS2IVF42(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIVF42ISS2IVF42):
    r"""Proxy of C++ itkMaskNegatedImageFilterIVF42ISS2IVF42 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIVF42ISS2IVF42_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIVF42ISS2IVF42_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_Clone(self)

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

        Parameters
        ----------
        outsideValue: itkVectorF4 const &

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkVectorF4"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF42ISS2IVF42

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIVF42ISS2IVF42.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIVF42ISS2IVF42.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIVF42ISS2IVF42.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIVF42ISS2IVF42 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_swigregister(itkMaskNegatedImageFilterIVF42ISS2IVF42)

def itkMaskNegatedImageFilterIVF42IUC2IVF42_New():
    return itkMaskNegatedImageFilterIVF42IUC2IVF42.New()

class itkMaskNegatedImageFilterIVF42IUC2IVF42(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIVF42IUC2IVF42):
    r"""Proxy of C++ itkMaskNegatedImageFilterIVF42IUC2IVF42 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIVF42IUC2IVF42_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIVF42IUC2IVF42_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_Clone(self)

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

        Parameters
        ----------
        outsideValue: itkVectorF4 const &

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkVectorF4"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC2"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF42IUC2IVF42

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIVF42IUC2IVF42.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIVF42IUC2IVF42.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIVF42IUC2IVF42.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIVF42IUC2IVF42 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_swigregister(itkMaskNegatedImageFilterIVF42IUC2IVF42)

def itkMaskNegatedImageFilterIVF43ISS3IVF43_New():
    return itkMaskNegatedImageFilterIVF43ISS3IVF43.New()

class itkMaskNegatedImageFilterIVF43ISS3IVF43(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIVF43ISS3IVF43):
    r"""Proxy of C++ itkMaskNegatedImageFilterIVF43ISS3IVF43 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIVF43ISS3IVF43_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIVF43ISS3IVF43_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_Clone(self)

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

        Parameters
        ----------
        outsideValue: itkVectorF4 const &

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkVectorF4"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> short const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageSS3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF43ISS3IVF43

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIVF43ISS3IVF43.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIVF43ISS3IVF43.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIVF43ISS3IVF43.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIVF43ISS3IVF43 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_swigregister(itkMaskNegatedImageFilterIVF43ISS3IVF43)

def itkMaskNegatedImageFilterIVF43IUC3IVF43_New():
    return itkMaskNegatedImageFilterIVF43IUC3IVF43.New()

class itkMaskNegatedImageFilterIVF43IUC3IVF43(itk.itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIVF43IUC3IVF43):
    r"""Proxy of C++ itkMaskNegatedImageFilterIVF43IUC3IVF43 class."""

    thisown = property(lambda x: x.this.own(), 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__() -> itkMaskNegatedImageFilterIVF43IUC3IVF43_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMaskNegatedImageFilterIVF43IUC3IVF43_Pointer"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_Clone(self)

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

        Parameters
        ----------
        outsideValue: itkVectorF4 const &

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_SetOutsideValue(self, outsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(self) -> itkVectorF4"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_GetOutsideValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_SetMaskingValue(self, maskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(self) -> unsigned char const &"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_GetMaskingValue(self)

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_SetMaskImage(self, maskImage)

    def GetMaskImage(self):
        r"""GetMaskImage(self) -> itkImageUC3"""
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_GetMaskImage(self)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF43IUC3IVF43

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

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

        """
        return _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_cast(obj)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIVF43IUC3IVF43.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMaskNegatedImageFilterIVF43IUC3IVF43.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMaskNegatedImageFilterIVF43IUC3IVF43.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMaskNegatedImageFilterIVF43IUC3IVF43 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_swigregister(itkMaskNegatedImageFilterIVF43IUC3IVF43)

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_negated_image_filter(*args: itkt.ImageLike,  outside_value: Sequence[float]=..., masking_value: int=..., mask_image: itkt.Image=..., constant1: Sequence[float]=..., constant2: int=..., constant: int=...,**kwargs)-> itkt.ImageSourceReturn:
    """Functional interface for MaskNegatedImageFilter"""
    import itk

    kwarg_typehints = { 'outside_value':outside_value,'masking_value':masking_value,'mask_image':mask_image,'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.MaskNegatedImageFilter.New(*args, **kwargs)

    return instance.__internal_call__()

def mask_negated_image_filter_init_docstring():
    import itk
    from itk.support import template_class

    filter_class = itk.ITKImageIntensity.MaskNegatedImageFilter
    mask_negated_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_negated_image_filter.__doc__ = filter_object.__doc__



