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

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

_swig_new_instance_method = _itkMaskNegatedImageFilterPython.SWIG_PyInstanceMethod_New
_swig_new_static_method = _itkMaskNegatedImageFilterPython.SWIG_PyStaticMethod_New

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


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

def itkMaskNegatedImageFilterICF3IUC3ICF3_New():
  return itkMaskNegatedImageFilterICF3IUC3ICF3.New()


def itkMaskNegatedImageFilterICF3IUC3ICF3_Superclass_New():
  return itkMaskNegatedImageFilterICF3IUC3ICF3_Superclass.New()


def itkMaskNegatedImageFilterICF2IUC2ICF2_New():
  return itkMaskNegatedImageFilterICF2IUC2ICF2.New()


def itkMaskNegatedImageFilterICF2IUC2ICF2_Superclass_New():
  return itkMaskNegatedImageFilterICF2IUC2ICF2_Superclass.New()


def itkMaskNegatedImageFilterICF3ISS3ICF3_New():
  return itkMaskNegatedImageFilterICF3ISS3ICF3.New()


def itkMaskNegatedImageFilterICF3ISS3ICF3_Superclass_New():
  return itkMaskNegatedImageFilterICF3ISS3ICF3_Superclass.New()


def itkMaskNegatedImageFilterICF2ISS2ICF2_New():
  return itkMaskNegatedImageFilterICF2ISS2ICF2.New()


def itkMaskNegatedImageFilterICF2ISS2ICF2_Superclass_New():
  return itkMaskNegatedImageFilterICF2ISS2ICF2_Superclass.New()


def itkMaskNegatedImageFilterIF3IUC3IF3_New():
  return itkMaskNegatedImageFilterIF3IUC3IF3.New()


def itkMaskNegatedImageFilterIF3IUC3IF3_Superclass_New():
  return itkMaskNegatedImageFilterIF3IUC3IF3_Superclass.New()


def itkMaskNegatedImageFilterIF2IUC2IF2_New():
  return itkMaskNegatedImageFilterIF2IUC2IF2.New()


def itkMaskNegatedImageFilterIF2IUC2IF2_Superclass_New():
  return itkMaskNegatedImageFilterIF2IUC2IF2_Superclass.New()


def itkMaskNegatedImageFilterIF3ISS3IF3_New():
  return itkMaskNegatedImageFilterIF3ISS3IF3.New()


def itkMaskNegatedImageFilterIF3ISS3IF3_Superclass_New():
  return itkMaskNegatedImageFilterIF3ISS3IF3_Superclass.New()


def itkMaskNegatedImageFilterIF2ISS2IF2_New():
  return itkMaskNegatedImageFilterIF2ISS2IF2.New()


def itkMaskNegatedImageFilterIF2ISS2IF2_Superclass_New():
  return itkMaskNegatedImageFilterIF2ISS2IF2_Superclass.New()


def itkMaskNegatedImageFilterIUC3IUC3IUC3_New():
  return itkMaskNegatedImageFilterIUC3IUC3IUC3.New()


def itkMaskNegatedImageFilterIUC3IUC3IUC3_Superclass_New():
  return itkMaskNegatedImageFilterIUC3IUC3IUC3_Superclass.New()


def itkMaskNegatedImageFilterIUC2IUC2IUC2_New():
  return itkMaskNegatedImageFilterIUC2IUC2IUC2.New()


def itkMaskNegatedImageFilterIUC2IUC2IUC2_Superclass_New():
  return itkMaskNegatedImageFilterIUC2IUC2IUC2_Superclass.New()


def itkMaskNegatedImageFilterIUC3ISS3IUC3_New():
  return itkMaskNegatedImageFilterIUC3ISS3IUC3.New()


def itkMaskNegatedImageFilterIUC3ISS3IUC3_Superclass_New():
  return itkMaskNegatedImageFilterIUC3ISS3IUC3_Superclass.New()


def itkMaskNegatedImageFilterIUC2ISS2IUC2_New():
  return itkMaskNegatedImageFilterIUC2ISS2IUC2.New()


def itkMaskNegatedImageFilterIUC2ISS2IUC2_Superclass_New():
  return itkMaskNegatedImageFilterIUC2ISS2IUC2_Superclass.New()


def itkMaskNegatedImageFilterISS3IUC3ISS3_New():
  return itkMaskNegatedImageFilterISS3IUC3ISS3.New()


def itkMaskNegatedImageFilterISS3IUC3ISS3_Superclass_New():
  return itkMaskNegatedImageFilterISS3IUC3ISS3_Superclass.New()


def itkMaskNegatedImageFilterISS2IUC2ISS2_New():
  return itkMaskNegatedImageFilterISS2IUC2ISS2.New()


def itkMaskNegatedImageFilterISS2IUC2ISS2_Superclass_New():
  return itkMaskNegatedImageFilterISS2IUC2ISS2_Superclass.New()


def itkMaskNegatedImageFilterISS3ISS3ISS3_New():
  return itkMaskNegatedImageFilterISS3ISS3ISS3.New()


def itkMaskNegatedImageFilterISS3ISS3ISS3_Superclass_New():
  return itkMaskNegatedImageFilterISS3ISS3ISS3_Superclass.New()


def itkMaskNegatedImageFilterISS2ISS2ISS2_New():
  return itkMaskNegatedImageFilterISS2ISS2ISS2.New()


def itkMaskNegatedImageFilterISS2ISS2ISS2_Superclass_New():
  return itkMaskNegatedImageFilterISS2ISS2ISS2_Superclass.New()


def itkMaskNegatedImageFilterICVF43IUC3ICVF43_New():
  return itkMaskNegatedImageFilterICVF43IUC3ICVF43.New()


def itkMaskNegatedImageFilterICVF43IUC3ICVF43_Superclass_New():
  return itkMaskNegatedImageFilterICVF43IUC3ICVF43_Superclass.New()


def itkMaskNegatedImageFilterICVF42IUC2ICVF42_New():
  return itkMaskNegatedImageFilterICVF42IUC2ICVF42.New()


def itkMaskNegatedImageFilterICVF42IUC2ICVF42_Superclass_New():
  return itkMaskNegatedImageFilterICVF42IUC2ICVF42_Superclass.New()


def itkMaskNegatedImageFilterICVF33IUC3ICVF33_New():
  return itkMaskNegatedImageFilterICVF33IUC3ICVF33.New()


def itkMaskNegatedImageFilterICVF33IUC3ICVF33_Superclass_New():
  return itkMaskNegatedImageFilterICVF33IUC3ICVF33_Superclass.New()


def itkMaskNegatedImageFilterICVF32IUC2ICVF32_New():
  return itkMaskNegatedImageFilterICVF32IUC2ICVF32.New()


def itkMaskNegatedImageFilterICVF32IUC2ICVF32_Superclass_New():
  return itkMaskNegatedImageFilterICVF32IUC2ICVF32_Superclass.New()


def itkMaskNegatedImageFilterICVF23IUC3ICVF23_New():
  return itkMaskNegatedImageFilterICVF23IUC3ICVF23.New()


def itkMaskNegatedImageFilterICVF23IUC3ICVF23_Superclass_New():
  return itkMaskNegatedImageFilterICVF23IUC3ICVF23_Superclass.New()


def itkMaskNegatedImageFilterICVF22IUC2ICVF22_New():
  return itkMaskNegatedImageFilterICVF22IUC2ICVF22.New()


def itkMaskNegatedImageFilterICVF22IUC2ICVF22_Superclass_New():
  return itkMaskNegatedImageFilterICVF22IUC2ICVF22_Superclass.New()


def itkMaskNegatedImageFilterICVF43ISS3ICVF43_New():
  return itkMaskNegatedImageFilterICVF43ISS3ICVF43.New()


def itkMaskNegatedImageFilterICVF43ISS3ICVF43_Superclass_New():
  return itkMaskNegatedImageFilterICVF43ISS3ICVF43_Superclass.New()


def itkMaskNegatedImageFilterICVF42ISS2ICVF42_New():
  return itkMaskNegatedImageFilterICVF42ISS2ICVF42.New()


def itkMaskNegatedImageFilterICVF42ISS2ICVF42_Superclass_New():
  return itkMaskNegatedImageFilterICVF42ISS2ICVF42_Superclass.New()


def itkMaskNegatedImageFilterICVF33ISS3ICVF33_New():
  return itkMaskNegatedImageFilterICVF33ISS3ICVF33.New()


def itkMaskNegatedImageFilterICVF33ISS3ICVF33_Superclass_New():
  return itkMaskNegatedImageFilterICVF33ISS3ICVF33_Superclass.New()


def itkMaskNegatedImageFilterICVF32ISS2ICVF32_New():
  return itkMaskNegatedImageFilterICVF32ISS2ICVF32.New()


def itkMaskNegatedImageFilterICVF32ISS2ICVF32_Superclass_New():
  return itkMaskNegatedImageFilterICVF32ISS2ICVF32_Superclass.New()


def itkMaskNegatedImageFilterICVF23ISS3ICVF23_New():
  return itkMaskNegatedImageFilterICVF23ISS3ICVF23.New()


def itkMaskNegatedImageFilterICVF23ISS3ICVF23_Superclass_New():
  return itkMaskNegatedImageFilterICVF23ISS3ICVF23_Superclass.New()


def itkMaskNegatedImageFilterICVF22ISS2ICVF22_New():
  return itkMaskNegatedImageFilterICVF22ISS2ICVF22.New()


def itkMaskNegatedImageFilterICVF22ISS2ICVF22_Superclass_New():
  return itkMaskNegatedImageFilterICVF22ISS2ICVF22_Superclass.New()


def itkMaskNegatedImageFilterIVF43IUC3IVF43_New():
  return itkMaskNegatedImageFilterIVF43IUC3IVF43.New()


def itkMaskNegatedImageFilterIVF43IUC3IVF43_Superclass_New():
  return itkMaskNegatedImageFilterIVF43IUC3IVF43_Superclass.New()


def itkMaskNegatedImageFilterIVF42IUC2IVF42_New():
  return itkMaskNegatedImageFilterIVF42IUC2IVF42.New()


def itkMaskNegatedImageFilterIVF42IUC2IVF42_Superclass_New():
  return itkMaskNegatedImageFilterIVF42IUC2IVF42_Superclass.New()


def itkMaskNegatedImageFilterIVF33IUC3IVF33_New():
  return itkMaskNegatedImageFilterIVF33IUC3IVF33.New()


def itkMaskNegatedImageFilterIVF33IUC3IVF33_Superclass_New():
  return itkMaskNegatedImageFilterIVF33IUC3IVF33_Superclass.New()


def itkMaskNegatedImageFilterIVF32IUC2IVF32_New():
  return itkMaskNegatedImageFilterIVF32IUC2IVF32.New()


def itkMaskNegatedImageFilterIVF32IUC2IVF32_Superclass_New():
  return itkMaskNegatedImageFilterIVF32IUC2IVF32_Superclass.New()


def itkMaskNegatedImageFilterIVF23IUC3IVF23_New():
  return itkMaskNegatedImageFilterIVF23IUC3IVF23.New()


def itkMaskNegatedImageFilterIVF23IUC3IVF23_Superclass_New():
  return itkMaskNegatedImageFilterIVF23IUC3IVF23_Superclass.New()


def itkMaskNegatedImageFilterIVF22IUC2IVF22_New():
  return itkMaskNegatedImageFilterIVF22IUC2IVF22.New()


def itkMaskNegatedImageFilterIVF22IUC2IVF22_Superclass_New():
  return itkMaskNegatedImageFilterIVF22IUC2IVF22_Superclass.New()


def itkMaskNegatedImageFilterIVF43ISS3IVF43_New():
  return itkMaskNegatedImageFilterIVF43ISS3IVF43.New()


def itkMaskNegatedImageFilterIVF43ISS3IVF43_Superclass_New():
  return itkMaskNegatedImageFilterIVF43ISS3IVF43_Superclass.New()


def itkMaskNegatedImageFilterIVF42ISS2IVF42_New():
  return itkMaskNegatedImageFilterIVF42ISS2IVF42.New()


def itkMaskNegatedImageFilterIVF42ISS2IVF42_Superclass_New():
  return itkMaskNegatedImageFilterIVF42ISS2IVF42_Superclass.New()


def itkMaskNegatedImageFilterIVF33ISS3IVF33_New():
  return itkMaskNegatedImageFilterIVF33ISS3IVF33.New()


def itkMaskNegatedImageFilterIVF33ISS3IVF33_Superclass_New():
  return itkMaskNegatedImageFilterIVF33ISS3IVF33_Superclass.New()


def itkMaskNegatedImageFilterIVF32ISS2IVF32_New():
  return itkMaskNegatedImageFilterIVF32ISS2IVF32.New()


def itkMaskNegatedImageFilterIVF32ISS2IVF32_Superclass_New():
  return itkMaskNegatedImageFilterIVF32ISS2IVF32_Superclass.New()


def itkMaskNegatedImageFilterIVF23ISS3IVF23_New():
  return itkMaskNegatedImageFilterIVF23ISS3IVF23.New()


def itkMaskNegatedImageFilterIVF23ISS3IVF23_Superclass_New():
  return itkMaskNegatedImageFilterIVF23ISS3IVF23_Superclass.New()


def itkMaskNegatedImageFilterIVF22ISS2IVF22_New():
  return itkMaskNegatedImageFilterIVF22ISS2IVF22.New()


def itkMaskNegatedImageFilterIVF22ISS2IVF22_Superclass_New():
  return itkMaskNegatedImageFilterIVF22ISS2IVF22_Superclass.New()


def itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_New():
  return itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3.New()


def itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_New():
  return itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass.New()


def itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_New():
  return itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2.New()


def itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_New():
  return itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass.New()


def itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_New():
  return itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3.New()


def itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_New():
  return itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass.New()


def itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_New():
  return itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2.New()


def itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_New():
  return itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass.New()


def itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_New():
  return itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3.New()


def itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Superclass_New():
  return itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Superclass.New()


def itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_New():
  return itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2.New()


def itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Superclass_New():
  return itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Superclass.New()


def itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_New():
  return itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3.New()


def itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Superclass_New():
  return itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Superclass.New()


def itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_New():
  return itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2.New()


def itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Superclass_New():
  return itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Superclass.New()

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

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICF2ISS2ICF2_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICF2ISS2ICF2_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterICF2ISS2ICF2_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_Superclass_swigregister(itkMaskNegatedImageFilterICF2ISS2ICF2_Superclass)
class itkMaskNegatedImageFilterICF2IUC2ICF2_Superclass(itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF2ICF2):
    r"""Proxy of C++ itkMaskNegatedImageFilterICF2IUC2ICF2_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICF2IUC2ICF2_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICF2IUC2ICF2_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterICF2IUC2ICF2_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_Superclass_swigregister(itkMaskNegatedImageFilterICF2IUC2ICF2_Superclass)
class itkMaskNegatedImageFilterICF3ISS3ICF3_Superclass(itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3ICF3):
    r"""Proxy of C++ itkMaskNegatedImageFilterICF3ISS3ICF3_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICF3ISS3ICF3_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICF3ISS3ICF3_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterICF3ISS3ICF3_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_Superclass_swigregister(itkMaskNegatedImageFilterICF3ISS3ICF3_Superclass)
class itkMaskNegatedImageFilterICF3IUC3ICF3_Superclass(itkInPlaceImageFilterBPython.itkInPlaceImageFilterICF3ICF3):
    r"""Proxy of C++ itkMaskNegatedImageFilterICF3IUC3ICF3_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICF3IUC3ICF3_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICF3IUC3ICF3_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterICF3IUC3ICF3_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_Superclass_swigregister(itkMaskNegatedImageFilterICF3IUC3ICF3_Superclass)
class itkMaskNegatedImageFilterICVF22ISS2ICVF22_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF22ICVF22):
    r"""Proxy of C++ itkMaskNegatedImageFilterICVF22ISS2ICVF22_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF22ISS2ICVF22_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICVF22ISS2ICVF22_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterICVF22ISS2ICVF22_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_Superclass_swigregister(itkMaskNegatedImageFilterICVF22ISS2ICVF22_Superclass)
class itkMaskNegatedImageFilterICVF22IUC2ICVF22_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF22ICVF22):
    r"""Proxy of C++ itkMaskNegatedImageFilterICVF22IUC2ICVF22_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF22IUC2ICVF22_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICVF22IUC2ICVF22_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterICVF22IUC2ICVF22_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_Superclass_swigregister(itkMaskNegatedImageFilterICVF22IUC2ICVF22_Superclass)
class itkMaskNegatedImageFilterICVF23ISS3ICVF23_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF23ICVF23):
    r"""Proxy of C++ itkMaskNegatedImageFilterICVF23ISS3ICVF23_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF23ISS3ICVF23_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICVF23ISS3ICVF23_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterICVF23ISS3ICVF23_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_Superclass_swigregister(itkMaskNegatedImageFilterICVF23ISS3ICVF23_Superclass)
class itkMaskNegatedImageFilterICVF23IUC3ICVF23_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF23ICVF23):
    r"""Proxy of C++ itkMaskNegatedImageFilterICVF23IUC3ICVF23_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF23IUC3ICVF23_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICVF23IUC3ICVF23_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterICVF23IUC3ICVF23_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_Superclass_swigregister(itkMaskNegatedImageFilterICVF23IUC3ICVF23_Superclass)
class itkMaskNegatedImageFilterICVF32ISS2ICVF32_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF32ICVF32):
    r"""Proxy of C++ itkMaskNegatedImageFilterICVF32ISS2ICVF32_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF32ISS2ICVF32_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICVF32ISS2ICVF32_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterICVF32ISS2ICVF32_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_Superclass_swigregister(itkMaskNegatedImageFilterICVF32ISS2ICVF32_Superclass)
class itkMaskNegatedImageFilterICVF32IUC2ICVF32_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF32ICVF32):
    r"""Proxy of C++ itkMaskNegatedImageFilterICVF32IUC2ICVF32_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF32IUC2ICVF32_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICVF32IUC2ICVF32_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterICVF32IUC2ICVF32_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_Superclass_swigregister(itkMaskNegatedImageFilterICVF32IUC2ICVF32_Superclass)
class itkMaskNegatedImageFilterICVF33ISS3ICVF33_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF33ICVF33):
    r"""Proxy of C++ itkMaskNegatedImageFilterICVF33ISS3ICVF33_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF33ISS3ICVF33_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICVF33ISS3ICVF33_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterICVF33ISS3ICVF33_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_Superclass_swigregister(itkMaskNegatedImageFilterICVF33ISS3ICVF33_Superclass)
class itkMaskNegatedImageFilterICVF33IUC3ICVF33_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF33ICVF33):
    r"""Proxy of C++ itkMaskNegatedImageFilterICVF33IUC3ICVF33_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF33IUC3ICVF33_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICVF33IUC3ICVF33_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterICVF33IUC3ICVF33_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_Superclass_swigregister(itkMaskNegatedImageFilterICVF33IUC3ICVF33_Superclass)
class itkMaskNegatedImageFilterICVF42ISS2ICVF42_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF42ICVF42):
    r"""Proxy of C++ itkMaskNegatedImageFilterICVF42ISS2ICVF42_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF42ISS2ICVF42_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICVF42ISS2ICVF42_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterICVF42ISS2ICVF42_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_Superclass_swigregister(itkMaskNegatedImageFilterICVF42ISS2ICVF42_Superclass)
class itkMaskNegatedImageFilterICVF42IUC2ICVF42_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF42ICVF42):
    r"""Proxy of C++ itkMaskNegatedImageFilterICVF42IUC2ICVF42_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF42IUC2ICVF42_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICVF42IUC2ICVF42_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterICVF42IUC2ICVF42_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_Superclass_swigregister(itkMaskNegatedImageFilterICVF42IUC2ICVF42_Superclass)
class itkMaskNegatedImageFilterICVF43ISS3ICVF43_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF43ICVF43):
    r"""Proxy of C++ itkMaskNegatedImageFilterICVF43ISS3ICVF43_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF43ISS3ICVF43_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICVF43ISS3ICVF43_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterICVF43ISS3ICVF43_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_Superclass_swigregister(itkMaskNegatedImageFilterICVF43ISS3ICVF43_Superclass)
class itkMaskNegatedImageFilterICVF43IUC3ICVF43_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterICVF43ICVF43):
    r"""Proxy of C++ itkMaskNegatedImageFilterICVF43IUC3ICVF43_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF43IUC3ICVF43_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterICVF43IUC3ICVF43_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterICVF43IUC3ICVF43_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_Superclass_swigregister(itkMaskNegatedImageFilterICVF43IUC3ICVF43_Superclass)
class itkMaskNegatedImageFilterIF2ISS2IF2_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IF2):
    r"""Proxy of C++ itkMaskNegatedImageFilterIF2ISS2IF2_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIF2ISS2IF2_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIF2ISS2IF2_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIF2ISS2IF2_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_Superclass_swigregister(itkMaskNegatedImageFilterIF2ISS2IF2_Superclass)
class itkMaskNegatedImageFilterIF2IUC2IF2_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF2IF2):
    r"""Proxy of C++ itkMaskNegatedImageFilterIF2IUC2IF2_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIF2IUC2IF2_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIF2IUC2IF2_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIF2IUC2IF2_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_Superclass_swigregister(itkMaskNegatedImageFilterIF2IUC2IF2_Superclass)
class itkMaskNegatedImageFilterIF3ISS3IF3_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IF3):
    r"""Proxy of C++ itkMaskNegatedImageFilterIF3ISS3IF3_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIF3ISS3IF3_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIF3ISS3IF3_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIF3ISS3IF3_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_Superclass_swigregister(itkMaskNegatedImageFilterIF3ISS3IF3_Superclass)
class itkMaskNegatedImageFilterIF3IUC3IF3_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIF3IF3):
    r"""Proxy of C++ itkMaskNegatedImageFilterIF3IUC3IF3_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIF3IUC3IF3_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIF3IUC3IF3_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIF3IUC3IF3_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_Superclass_swigregister(itkMaskNegatedImageFilterIF3IUC3IF3_Superclass)
class itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC2IRGBAUC2):
    r"""Proxy of C++ itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass_swigregister(itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass)
class itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC2IRGBAUC2):
    r"""Proxy of C++ itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass_swigregister(itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass)
class itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC3IRGBAUC3):
    r"""Proxy of C++ itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass_swigregister(itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass)
class itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBAUC3IRGBAUC3):
    r"""Proxy of C++ itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass_swigregister(itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass)
class itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC2IRGBUC2):
    r"""Proxy of C++ itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Superclass_swigregister(itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Superclass)
class itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC2IRGBUC2):
    r"""Proxy of C++ itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Superclass_swigregister(itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Superclass)
class itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC3IRGBUC3):
    r"""Proxy of C++ itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Superclass_swigregister(itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Superclass)
class itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIRGBUC3IRGBUC3):
    r"""Proxy of C++ itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Superclass_swigregister(itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Superclass)
class itkMaskNegatedImageFilterISS2ISS2ISS2_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2ISS2):
    r"""Proxy of C++ itkMaskNegatedImageFilterISS2ISS2ISS2_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterISS2ISS2ISS2_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterISS2ISS2ISS2_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterISS2ISS2ISS2_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_Superclass_swigregister(itkMaskNegatedImageFilterISS2ISS2ISS2_Superclass)
class itkMaskNegatedImageFilterISS2IUC2ISS2_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS2ISS2):
    r"""Proxy of C++ itkMaskNegatedImageFilterISS2IUC2ISS2_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterISS2IUC2ISS2_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterISS2IUC2ISS2_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterISS2IUC2ISS2_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_Superclass_swigregister(itkMaskNegatedImageFilterISS2IUC2ISS2_Superclass)
class itkMaskNegatedImageFilterISS3ISS3ISS3_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3ISS3):
    r"""Proxy of C++ itkMaskNegatedImageFilterISS3ISS3ISS3_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterISS3ISS3ISS3_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterISS3ISS3ISS3_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterISS3ISS3ISS3_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_Superclass_swigregister(itkMaskNegatedImageFilterISS3ISS3ISS3_Superclass)
class itkMaskNegatedImageFilterISS3IUC3ISS3_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterISS3ISS3):
    r"""Proxy of C++ itkMaskNegatedImageFilterISS3IUC3ISS3_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterISS3IUC3ISS3_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterISS3IUC3ISS3_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterISS3IUC3ISS3_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_Superclass_swigregister(itkMaskNegatedImageFilterISS3IUC3ISS3_Superclass)
class itkMaskNegatedImageFilterIUC2ISS2IUC2_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IUC2):
    r"""Proxy of C++ itkMaskNegatedImageFilterIUC2ISS2IUC2_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIUC2ISS2IUC2_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIUC2ISS2IUC2_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIUC2ISS2IUC2_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_Superclass_swigregister(itkMaskNegatedImageFilterIUC2ISS2IUC2_Superclass)
class itkMaskNegatedImageFilterIUC2IUC2IUC2_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC2IUC2):
    r"""Proxy of C++ itkMaskNegatedImageFilterIUC2IUC2IUC2_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIUC2IUC2IUC2_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIUC2IUC2IUC2_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIUC2IUC2IUC2_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_Superclass_swigregister(itkMaskNegatedImageFilterIUC2IUC2IUC2_Superclass)
class itkMaskNegatedImageFilterIUC3ISS3IUC3_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IUC3):
    r"""Proxy of C++ itkMaskNegatedImageFilterIUC3ISS3IUC3_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIUC3ISS3IUC3_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIUC3ISS3IUC3_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIUC3ISS3IUC3_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_Superclass_swigregister(itkMaskNegatedImageFilterIUC3ISS3IUC3_Superclass)
class itkMaskNegatedImageFilterIUC3IUC3IUC3_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIUC3IUC3):
    r"""Proxy of C++ itkMaskNegatedImageFilterIUC3IUC3IUC3_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIUC3IUC3IUC3_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIUC3IUC3IUC3_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIUC3IUC3IUC3_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_Superclass_swigregister(itkMaskNegatedImageFilterIUC3IUC3IUC3_Superclass)
class itkMaskNegatedImageFilterIVF22ISS2IVF22_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF22IVF22):
    r"""Proxy of C++ itkMaskNegatedImageFilterIVF22ISS2IVF22_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF22ISS2IVF22_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIVF22ISS2IVF22_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIVF22ISS2IVF22_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_Superclass_swigregister(itkMaskNegatedImageFilterIVF22ISS2IVF22_Superclass)
class itkMaskNegatedImageFilterIVF22IUC2IVF22_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF22IVF22):
    r"""Proxy of C++ itkMaskNegatedImageFilterIVF22IUC2IVF22_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF22IUC2IVF22_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIVF22IUC2IVF22_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIVF22IUC2IVF22_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_Superclass_swigregister(itkMaskNegatedImageFilterIVF22IUC2IVF22_Superclass)
class itkMaskNegatedImageFilterIVF23ISS3IVF23_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF23IVF23):
    r"""Proxy of C++ itkMaskNegatedImageFilterIVF23ISS3IVF23_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF23ISS3IVF23_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIVF23ISS3IVF23_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIVF23ISS3IVF23_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_Superclass_swigregister(itkMaskNegatedImageFilterIVF23ISS3IVF23_Superclass)
class itkMaskNegatedImageFilterIVF23IUC3IVF23_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF23IVF23):
    r"""Proxy of C++ itkMaskNegatedImageFilterIVF23IUC3IVF23_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF23IUC3IVF23_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIVF23IUC3IVF23_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIVF23IUC3IVF23_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_Superclass_swigregister(itkMaskNegatedImageFilterIVF23IUC3IVF23_Superclass)
class itkMaskNegatedImageFilterIVF32ISS2IVF32_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF32IVF32):
    r"""Proxy of C++ itkMaskNegatedImageFilterIVF32ISS2IVF32_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF32ISS2IVF32_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIVF32ISS2IVF32_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIVF32ISS2IVF32_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_Superclass_swigregister(itkMaskNegatedImageFilterIVF32ISS2IVF32_Superclass)
class itkMaskNegatedImageFilterIVF32IUC2IVF32_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF32IVF32):
    r"""Proxy of C++ itkMaskNegatedImageFilterIVF32IUC2IVF32_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF32IUC2IVF32_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIVF32IUC2IVF32_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIVF32IUC2IVF32_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_Superclass_swigregister(itkMaskNegatedImageFilterIVF32IUC2IVF32_Superclass)
class itkMaskNegatedImageFilterIVF33ISS3IVF33_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF33IVF33):
    r"""Proxy of C++ itkMaskNegatedImageFilterIVF33ISS3IVF33_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF33ISS3IVF33_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIVF33ISS3IVF33_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIVF33ISS3IVF33_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_Superclass_swigregister(itkMaskNegatedImageFilterIVF33ISS3IVF33_Superclass)
class itkMaskNegatedImageFilterIVF33IUC3IVF33_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF33IVF33):
    r"""Proxy of C++ itkMaskNegatedImageFilterIVF33IUC3IVF33_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF33IUC3IVF33_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIVF33IUC3IVF33_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIVF33IUC3IVF33_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_Superclass_swigregister(itkMaskNegatedImageFilterIVF33IUC3IVF33_Superclass)
class itkMaskNegatedImageFilterIVF42ISS2IVF42_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF42IVF42):
    r"""Proxy of C++ itkMaskNegatedImageFilterIVF42ISS2IVF42_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF42ISS2IVF42_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIVF42ISS2IVF42_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIVF42ISS2IVF42_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_Superclass_swigregister(itkMaskNegatedImageFilterIVF42ISS2IVF42_Superclass)
class itkMaskNegatedImageFilterIVF42IUC2IVF42_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF42IVF42):
    r"""Proxy of C++ itkMaskNegatedImageFilterIVF42IUC2IVF42_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF42IUC2IVF42_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIVF42IUC2IVF42_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIVF42IUC2IVF42_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_Superclass_swigregister(itkMaskNegatedImageFilterIVF42IUC2IVF42_Superclass)
class itkMaskNegatedImageFilterIVF43ISS3IVF43_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF43IVF43):
    r"""Proxy of C++ itkMaskNegatedImageFilterIVF43ISS3IVF43_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF43ISS3IVF43_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIVF43ISS3IVF43_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIVF43ISS3IVF43_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_Superclass_swigregister(itkMaskNegatedImageFilterIVF43ISS3IVF43_Superclass)
class itkMaskNegatedImageFilterIVF43IUC3IVF43_Superclass(itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF43IVF43):
    r"""Proxy of C++ itkMaskNegatedImageFilterIVF43IUC3IVF43_Superclass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_Superclass___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_Superclass_Clone)
    SetInput1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_Superclass_SetInput1)
    SetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_Superclass_SetConstant1)
    GetConstant1 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_Superclass_GetConstant1)
    SetInput2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_Superclass_SetInput2)
    SetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_Superclass_SetConstant2)
    SetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_Superclass_SetConstant)
    GetConstant = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_Superclass_GetConstant)
    GetConstant2 = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_Superclass_GetConstant2)
    GetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_Superclass_GetFunctor)
    SetFunctor = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_Superclass_SetFunctor)
    SameDimensionCheck1 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_Superclass_SameDimensionCheck1
    
    SameDimensionCheck2 = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_Superclass_SameDimensionCheck2
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF43IUC3IVF43_Superclass
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_Superclass_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_Superclass_GetPointer)

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

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

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

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

        Ex:

          itkMaskNegatedImageFilterIVF43IUC3IVF43_Superclass.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMaskNegatedImageFilterIVF43IUC3IVF43_Superclass in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_Superclass_swigregister(itkMaskNegatedImageFilterIVF43IUC3IVF43_Superclass)
class itkMaskNegatedImageFilterICF2ISS2ICF2(itkMaskNegatedImageFilterICF2ISS2ICF2_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICF2ISS2ICF2
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_GetPointer)

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


# Register itkMaskNegatedImageFilterICF2ISS2ICF2 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2ISS2ICF2_swigregister(itkMaskNegatedImageFilterICF2ISS2ICF2)
class itkMaskNegatedImageFilterICF2IUC2ICF2(itkMaskNegatedImageFilterICF2IUC2ICF2_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICF2IUC2ICF2
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_GetPointer)

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


# Register itkMaskNegatedImageFilterICF2IUC2ICF2 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF2IUC2ICF2_swigregister(itkMaskNegatedImageFilterICF2IUC2ICF2)
class itkMaskNegatedImageFilterICF3ISS3ICF3(itkMaskNegatedImageFilterICF3ISS3ICF3_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICF3ISS3ICF3
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_GetPointer)

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


# Register itkMaskNegatedImageFilterICF3ISS3ICF3 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3ISS3ICF3_swigregister(itkMaskNegatedImageFilterICF3ISS3ICF3)
class itkMaskNegatedImageFilterICF3IUC3ICF3(itkMaskNegatedImageFilterICF3IUC3ICF3_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICF3IUC3ICF3
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_GetPointer)

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


# Register itkMaskNegatedImageFilterICF3IUC3ICF3 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICF3IUC3ICF3_swigregister(itkMaskNegatedImageFilterICF3IUC3ICF3)
class itkMaskNegatedImageFilterICVF22ISS2ICVF22(itkMaskNegatedImageFilterICVF22ISS2ICVF22_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF22ISS2ICVF22
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_GetPointer)

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


# Register itkMaskNegatedImageFilterICVF22ISS2ICVF22 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22ISS2ICVF22_swigregister(itkMaskNegatedImageFilterICVF22ISS2ICVF22)
class itkMaskNegatedImageFilterICVF22IUC2ICVF22(itkMaskNegatedImageFilterICVF22IUC2ICVF22_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF22IUC2ICVF22
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_GetPointer)

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


# Register itkMaskNegatedImageFilterICVF22IUC2ICVF22 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF22IUC2ICVF22_swigregister(itkMaskNegatedImageFilterICVF22IUC2ICVF22)
class itkMaskNegatedImageFilterICVF23ISS3ICVF23(itkMaskNegatedImageFilterICVF23ISS3ICVF23_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF23ISS3ICVF23
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_GetPointer)

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


# Register itkMaskNegatedImageFilterICVF23ISS3ICVF23 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23ISS3ICVF23_swigregister(itkMaskNegatedImageFilterICVF23ISS3ICVF23)
class itkMaskNegatedImageFilterICVF23IUC3ICVF23(itkMaskNegatedImageFilterICVF23IUC3ICVF23_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF23IUC3ICVF23
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_GetPointer)

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


# Register itkMaskNegatedImageFilterICVF23IUC3ICVF23 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF23IUC3ICVF23_swigregister(itkMaskNegatedImageFilterICVF23IUC3ICVF23)
class itkMaskNegatedImageFilterICVF32ISS2ICVF32(itkMaskNegatedImageFilterICVF32ISS2ICVF32_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF32ISS2ICVF32
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_GetPointer)

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


# Register itkMaskNegatedImageFilterICVF32ISS2ICVF32 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32ISS2ICVF32_swigregister(itkMaskNegatedImageFilterICVF32ISS2ICVF32)
class itkMaskNegatedImageFilterICVF32IUC2ICVF32(itkMaskNegatedImageFilterICVF32IUC2ICVF32_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF32IUC2ICVF32
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_GetPointer)

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


# Register itkMaskNegatedImageFilterICVF32IUC2ICVF32 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF32IUC2ICVF32_swigregister(itkMaskNegatedImageFilterICVF32IUC2ICVF32)
class itkMaskNegatedImageFilterICVF33ISS3ICVF33(itkMaskNegatedImageFilterICVF33ISS3ICVF33_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF33ISS3ICVF33
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_GetPointer)

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


# Register itkMaskNegatedImageFilterICVF33ISS3ICVF33 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33ISS3ICVF33_swigregister(itkMaskNegatedImageFilterICVF33ISS3ICVF33)
class itkMaskNegatedImageFilterICVF33IUC3ICVF33(itkMaskNegatedImageFilterICVF33IUC3ICVF33_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF33IUC3ICVF33
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_GetPointer)

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


# Register itkMaskNegatedImageFilterICVF33IUC3ICVF33 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF33IUC3ICVF33_swigregister(itkMaskNegatedImageFilterICVF33IUC3ICVF33)
class itkMaskNegatedImageFilterICVF42ISS2ICVF42(itkMaskNegatedImageFilterICVF42ISS2ICVF42_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF42ISS2ICVF42
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_GetPointer)

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


# Register itkMaskNegatedImageFilterICVF42ISS2ICVF42 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42ISS2ICVF42_swigregister(itkMaskNegatedImageFilterICVF42ISS2ICVF42)
class itkMaskNegatedImageFilterICVF42IUC2ICVF42(itkMaskNegatedImageFilterICVF42IUC2ICVF42_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF42IUC2ICVF42
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_GetPointer)

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


# Register itkMaskNegatedImageFilterICVF42IUC2ICVF42 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF42IUC2ICVF42_swigregister(itkMaskNegatedImageFilterICVF42IUC2ICVF42)
class itkMaskNegatedImageFilterICVF43ISS3ICVF43(itkMaskNegatedImageFilterICVF43ISS3ICVF43_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF43ISS3ICVF43
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_GetPointer)

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


# Register itkMaskNegatedImageFilterICVF43ISS3ICVF43 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43ISS3ICVF43_swigregister(itkMaskNegatedImageFilterICVF43ISS3ICVF43)
class itkMaskNegatedImageFilterICVF43IUC3ICVF43(itkMaskNegatedImageFilterICVF43IUC3ICVF43_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterICVF43IUC3ICVF43
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_GetPointer)

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


# Register itkMaskNegatedImageFilterICVF43IUC3ICVF43 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterICVF43IUC3ICVF43_swigregister(itkMaskNegatedImageFilterICVF43IUC3ICVF43)
class itkMaskNegatedImageFilterIF2ISS2IF2(itkMaskNegatedImageFilterIF2ISS2IF2_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIF2ISS2IF2
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_GetPointer)

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


# Register itkMaskNegatedImageFilterIF2ISS2IF2 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2ISS2IF2_swigregister(itkMaskNegatedImageFilterIF2ISS2IF2)
class itkMaskNegatedImageFilterIF2IUC2IF2(itkMaskNegatedImageFilterIF2IUC2IF2_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIF2IUC2IF2
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_GetPointer)

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


# Register itkMaskNegatedImageFilterIF2IUC2IF2 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF2IUC2IF2_swigregister(itkMaskNegatedImageFilterIF2IUC2IF2)
class itkMaskNegatedImageFilterIF3ISS3IF3(itkMaskNegatedImageFilterIF3ISS3IF3_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIF3ISS3IF3
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_GetPointer)

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


# Register itkMaskNegatedImageFilterIF3ISS3IF3 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3ISS3IF3_swigregister(itkMaskNegatedImageFilterIF3ISS3IF3)
class itkMaskNegatedImageFilterIF3IUC3IF3(itkMaskNegatedImageFilterIF3IUC3IF3_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIF3IUC3IF3
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_GetPointer)

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


# Register itkMaskNegatedImageFilterIF3IUC3IF3 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIF3IUC3IF3_swigregister(itkMaskNegatedImageFilterIF3IUC3IF3)
class itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2(itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_GetPointer)

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


# Register itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2_swigregister(itkMaskNegatedImageFilterIRGBAUC2ISS2IRGBAUC2)
class itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2(itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_GetPointer)

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


# Register itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2_swigregister(itkMaskNegatedImageFilterIRGBAUC2IUC2IRGBAUC2)
class itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3(itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_GetPointer)

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


# Register itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3_swigregister(itkMaskNegatedImageFilterIRGBAUC3ISS3IRGBAUC3)
class itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3(itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_GetPointer)

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


# Register itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3_swigregister(itkMaskNegatedImageFilterIRGBAUC3IUC3IRGBAUC3)
class itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2(itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_GetPointer)

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


# Register itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2_swigregister(itkMaskNegatedImageFilterIRGBUC2ISS2IRGBUC2)
class itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2(itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_GetPointer)

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


# Register itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2_swigregister(itkMaskNegatedImageFilterIRGBUC2IUC2IRGBUC2)
class itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3(itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_GetPointer)

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


# Register itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3_swigregister(itkMaskNegatedImageFilterIRGBUC3ISS3IRGBUC3)
class itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3(itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_GetPointer)

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


# Register itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3_swigregister(itkMaskNegatedImageFilterIRGBUC3IUC3IRGBUC3)
class itkMaskNegatedImageFilterISS2ISS2ISS2(itkMaskNegatedImageFilterISS2ISS2ISS2_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterISS2ISS2ISS2
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_GetPointer)

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


# Register itkMaskNegatedImageFilterISS2ISS2ISS2 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2ISS2ISS2_swigregister(itkMaskNegatedImageFilterISS2ISS2ISS2)
class itkMaskNegatedImageFilterISS2IUC2ISS2(itkMaskNegatedImageFilterISS2IUC2ISS2_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterISS2IUC2ISS2
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_GetPointer)

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


# Register itkMaskNegatedImageFilterISS2IUC2ISS2 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS2IUC2ISS2_swigregister(itkMaskNegatedImageFilterISS2IUC2ISS2)
class itkMaskNegatedImageFilterISS3ISS3ISS3(itkMaskNegatedImageFilterISS3ISS3ISS3_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterISS3ISS3ISS3
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_GetPointer)

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


# Register itkMaskNegatedImageFilterISS3ISS3ISS3 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3ISS3ISS3_swigregister(itkMaskNegatedImageFilterISS3ISS3ISS3)
class itkMaskNegatedImageFilterISS3IUC3ISS3(itkMaskNegatedImageFilterISS3IUC3ISS3_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterISS3IUC3ISS3
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_GetPointer)

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


# Register itkMaskNegatedImageFilterISS3IUC3ISS3 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterISS3IUC3ISS3_swigregister(itkMaskNegatedImageFilterISS3IUC3ISS3)
class itkMaskNegatedImageFilterIUC2ISS2IUC2(itkMaskNegatedImageFilterIUC2ISS2IUC2_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIUC2ISS2IUC2
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_GetPointer)

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


# Register itkMaskNegatedImageFilterIUC2ISS2IUC2 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2ISS2IUC2_swigregister(itkMaskNegatedImageFilterIUC2ISS2IUC2)
class itkMaskNegatedImageFilterIUC2IUC2IUC2(itkMaskNegatedImageFilterIUC2IUC2IUC2_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIUC2IUC2IUC2
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_GetPointer)

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


# Register itkMaskNegatedImageFilterIUC2IUC2IUC2 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC2IUC2IUC2_swigregister(itkMaskNegatedImageFilterIUC2IUC2IUC2)
class itkMaskNegatedImageFilterIUC3ISS3IUC3(itkMaskNegatedImageFilterIUC3ISS3IUC3_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIUC3ISS3IUC3
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_GetPointer)

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


# Register itkMaskNegatedImageFilterIUC3ISS3IUC3 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3ISS3IUC3_swigregister(itkMaskNegatedImageFilterIUC3ISS3IUC3)
class itkMaskNegatedImageFilterIUC3IUC3IUC3(itkMaskNegatedImageFilterIUC3IUC3IUC3_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIUC3IUC3IUC3
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_GetPointer)

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


# Register itkMaskNegatedImageFilterIUC3IUC3IUC3 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIUC3IUC3IUC3_swigregister(itkMaskNegatedImageFilterIUC3IUC3IUC3)
class itkMaskNegatedImageFilterIVF22ISS2IVF22(itkMaskNegatedImageFilterIVF22ISS2IVF22_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF22ISS2IVF22
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_GetPointer)

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


# Register itkMaskNegatedImageFilterIVF22ISS2IVF22 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22ISS2IVF22_swigregister(itkMaskNegatedImageFilterIVF22ISS2IVF22)
class itkMaskNegatedImageFilterIVF22IUC2IVF22(itkMaskNegatedImageFilterIVF22IUC2IVF22_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF22IUC2IVF22
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_GetPointer)

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


# Register itkMaskNegatedImageFilterIVF22IUC2IVF22 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF22IUC2IVF22_swigregister(itkMaskNegatedImageFilterIVF22IUC2IVF22)
class itkMaskNegatedImageFilterIVF23ISS3IVF23(itkMaskNegatedImageFilterIVF23ISS3IVF23_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF23ISS3IVF23
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_GetPointer)

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


# Register itkMaskNegatedImageFilterIVF23ISS3IVF23 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23ISS3IVF23_swigregister(itkMaskNegatedImageFilterIVF23ISS3IVF23)
class itkMaskNegatedImageFilterIVF23IUC3IVF23(itkMaskNegatedImageFilterIVF23IUC3IVF23_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF23IUC3IVF23
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_GetPointer)

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


# Register itkMaskNegatedImageFilterIVF23IUC3IVF23 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF23IUC3IVF23_swigregister(itkMaskNegatedImageFilterIVF23IUC3IVF23)
class itkMaskNegatedImageFilterIVF32ISS2IVF32(itkMaskNegatedImageFilterIVF32ISS2IVF32_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF32ISS2IVF32
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_GetPointer)

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


# Register itkMaskNegatedImageFilterIVF32ISS2IVF32 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32ISS2IVF32_swigregister(itkMaskNegatedImageFilterIVF32ISS2IVF32)
class itkMaskNegatedImageFilterIVF32IUC2IVF32(itkMaskNegatedImageFilterIVF32IUC2IVF32_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF32IUC2IVF32
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_GetPointer)

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


# Register itkMaskNegatedImageFilterIVF32IUC2IVF32 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF32IUC2IVF32_swigregister(itkMaskNegatedImageFilterIVF32IUC2IVF32)
class itkMaskNegatedImageFilterIVF33ISS3IVF33(itkMaskNegatedImageFilterIVF33ISS3IVF33_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF33ISS3IVF33
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_GetPointer)

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


# Register itkMaskNegatedImageFilterIVF33ISS3IVF33 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33ISS3IVF33_swigregister(itkMaskNegatedImageFilterIVF33ISS3IVF33)
class itkMaskNegatedImageFilterIVF33IUC3IVF33(itkMaskNegatedImageFilterIVF33IUC3IVF33_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF33IUC3IVF33
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_GetPointer)

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


# Register itkMaskNegatedImageFilterIVF33IUC3IVF33 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF33IUC3IVF33_swigregister(itkMaskNegatedImageFilterIVF33IUC3IVF33)
class itkMaskNegatedImageFilterIVF42ISS2IVF42(itkMaskNegatedImageFilterIVF42ISS2IVF42_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF42ISS2IVF42
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_GetPointer)

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


# Register itkMaskNegatedImageFilterIVF42ISS2IVF42 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42ISS2IVF42_swigregister(itkMaskNegatedImageFilterIVF42ISS2IVF42)
class itkMaskNegatedImageFilterIVF42IUC2IVF42(itkMaskNegatedImageFilterIVF42IUC2IVF42_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF42IUC2IVF42
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_GetPointer)

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


# Register itkMaskNegatedImageFilterIVF42IUC2IVF42 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF42IUC2IVF42_swigregister(itkMaskNegatedImageFilterIVF42IUC2IVF42)
class itkMaskNegatedImageFilterIVF43ISS3IVF43(itkMaskNegatedImageFilterIVF43ISS3IVF43_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF43ISS3IVF43
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_GetPointer)

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


# Register itkMaskNegatedImageFilterIVF43ISS3IVF43 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43ISS3IVF43_swigregister(itkMaskNegatedImageFilterIVF43ISS3IVF43)
class itkMaskNegatedImageFilterIVF43IUC3IVF43(itkMaskNegatedImageFilterIVF43IUC3IVF43_Superclass):
    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
    __New_orig__ = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43___New_orig__)
    Clone = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_Clone)
    SetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_SetOutsideValue)
    GetOutsideValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_GetOutsideValue)
    SetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_SetMaskingValue)
    GetMaskingValue = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_GetMaskingValue)
    SetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_SetMaskImage)
    GetMaskImage = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_GetMaskImage)
    MaskEqualityComparableCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_MaskEqualityComparableCheck
    
    InputConvertibleToOutputCheck = _itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkMaskNegatedImageFilterPython.delete_itkMaskNegatedImageFilterIVF43IUC3IVF43
    cast = _swig_new_static_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_cast)
    GetPointer = _swig_new_instance_method(_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_GetPointer)

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


# Register itkMaskNegatedImageFilterIVF43IUC3IVF43 in _itkMaskNegatedImageFilterPython:
_itkMaskNegatedImageFilterPython.itkMaskNegatedImageFilterIVF43IUC3IVF43_swigregister(itkMaskNegatedImageFilterIVF43IUC3IVF43)

