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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


import weakref

class SwigPyIterator(object):
    r"""Proxy of C++ swig::SwigPyIterator class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_SwigPyIterator

    def value(self):
        r"""value(SwigPyIterator self) -> PyObject *"""
        return _SimpleITK.SwigPyIterator_value(self)

    def incr(self, n=1):
        r"""incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"""
        return _SimpleITK.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        r"""decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"""
        return _SimpleITK.SwigPyIterator_decr(self, n)

    def distance(self, x):
        r"""distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
        return _SimpleITK.SwigPyIterator_distance(self, x)

    def equal(self, x):
        r"""equal(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _SimpleITK.SwigPyIterator_equal(self, x)

    def copy(self):
        r"""copy(SwigPyIterator self) -> SwigPyIterator"""
        return _SimpleITK.SwigPyIterator_copy(self)

    def next(self):
        r"""next(SwigPyIterator self) -> PyObject *"""
        return _SimpleITK.SwigPyIterator_next(self)

    def __next__(self):
        r"""__next__(SwigPyIterator self) -> PyObject *"""
        return _SimpleITK.SwigPyIterator___next__(self)

    def previous(self):
        r"""previous(SwigPyIterator self) -> PyObject *"""
        return _SimpleITK.SwigPyIterator_previous(self)

    def advance(self, n):
        r"""advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _SimpleITK.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        r"""__eq__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _SimpleITK.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        r"""__ne__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _SimpleITK.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        r"""__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _SimpleITK.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        r"""__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _SimpleITK.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        r"""__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _SimpleITK.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        r"""
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
        """
        return _SimpleITK.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _SimpleITK:
_SimpleITK.SwigPyIterator_swigregister(SwigPyIterator)
class VectorBool(object):
    r"""Proxy of C++ std::vector< bool > class."""

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

    def iterator(self):
        r"""iterator(VectorBool self) -> SwigPyIterator"""
        return _SimpleITK.VectorBool_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorBool self) -> bool"""
        return _SimpleITK.VectorBool___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorBool self) -> bool"""
        return _SimpleITK.VectorBool___bool__(self)

    def __len__(self):
        r"""__len__(VectorBool self) -> std::vector< bool >::size_type"""
        return _SimpleITK.VectorBool___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(VectorBool self, std::vector< bool >::difference_type i, std::vector< bool >::difference_type j) -> VectorBool"""
        return _SimpleITK.VectorBool___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorBool self, std::vector< bool >::difference_type i, std::vector< bool >::difference_type j)
        __setslice__(VectorBool self, std::vector< bool >::difference_type i, std::vector< bool >::difference_type j, VectorBool v)
        """
        return _SimpleITK.VectorBool___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(VectorBool self, std::vector< bool >::difference_type i, std::vector< bool >::difference_type j)"""
        return _SimpleITK.VectorBool___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorBool self, std::vector< bool >::difference_type i)
        __delitem__(VectorBool self, SWIGPY_SLICEOBJECT * slice)
        """
        return _SimpleITK.VectorBool___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorBool self, SWIGPY_SLICEOBJECT * slice) -> VectorBool
        __getitem__(VectorBool self, std::vector< bool >::difference_type i) -> std::vector< bool >::value_type
        """
        return _SimpleITK.VectorBool___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorBool self, SWIGPY_SLICEOBJECT * slice, VectorBool v)
        __setitem__(VectorBool self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(VectorBool self, std::vector< bool >::difference_type i, std::vector< bool >::value_type x)
        """
        return _SimpleITK.VectorBool___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorBool self) -> std::vector< bool >::value_type"""
        return _SimpleITK.VectorBool_pop(self)

    def append(self, x):
        r"""append(VectorBool self, std::vector< bool >::value_type x)"""
        return _SimpleITK.VectorBool_append(self, x)

    def empty(self):
        r"""empty(VectorBool self) -> bool"""
        return _SimpleITK.VectorBool_empty(self)

    def size(self):
        r"""size(VectorBool self) -> std::vector< bool >::size_type"""
        return _SimpleITK.VectorBool_size(self)

    def swap(self, v):
        r"""swap(VectorBool self, VectorBool v)"""
        return _SimpleITK.VectorBool_swap(self, v)

    def begin(self):
        r"""begin(VectorBool self) -> std::vector< bool >::iterator"""
        return _SimpleITK.VectorBool_begin(self)

    def end(self):
        r"""end(VectorBool self) -> std::vector< bool >::iterator"""
        return _SimpleITK.VectorBool_end(self)

    def rbegin(self):
        r"""rbegin(VectorBool self) -> std::vector< bool >::reverse_iterator"""
        return _SimpleITK.VectorBool_rbegin(self)

    def rend(self):
        r"""rend(VectorBool self) -> std::vector< bool >::reverse_iterator"""
        return _SimpleITK.VectorBool_rend(self)

    def clear(self):
        r"""clear(VectorBool self)"""
        return _SimpleITK.VectorBool_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorBool self) -> std::vector< bool >::allocator_type"""
        return _SimpleITK.VectorBool_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorBool self)"""
        return _SimpleITK.VectorBool_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorBool self, std::vector< bool >::iterator pos) -> std::vector< bool >::iterator
        erase(VectorBool self, std::vector< bool >::iterator first, std::vector< bool >::iterator last) -> std::vector< bool >::iterator
        """
        return _SimpleITK.VectorBool_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorBool self) -> VectorBool
        __init__(VectorBool self, VectorBool other) -> VectorBool
        __init__(VectorBool self, std::vector< bool >::size_type size) -> VectorBool
        __init__(VectorBool self, std::vector< bool >::size_type size, std::vector< bool >::value_type value) -> VectorBool
        """
        _SimpleITK.VectorBool_swiginit(self, _SimpleITK.new_VectorBool(*args))

    def push_back(self, x):
        r"""push_back(VectorBool self, std::vector< bool >::value_type x)"""
        return _SimpleITK.VectorBool_push_back(self, x)

    def front(self):
        r"""front(VectorBool self) -> std::vector< bool >::value_type"""
        return _SimpleITK.VectorBool_front(self)

    def back(self):
        r"""back(VectorBool self) -> std::vector< bool >::value_type"""
        return _SimpleITK.VectorBool_back(self)

    def assign(self, n, x):
        r"""assign(VectorBool self, std::vector< bool >::size_type n, std::vector< bool >::value_type x)"""
        return _SimpleITK.VectorBool_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorBool self, std::vector< bool >::size_type new_size)
        resize(VectorBool self, std::vector< bool >::size_type new_size, std::vector< bool >::value_type x)
        """
        return _SimpleITK.VectorBool_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorBool self, std::vector< bool >::iterator pos, std::vector< bool >::value_type x) -> std::vector< bool >::iterator
        insert(VectorBool self, std::vector< bool >::iterator pos, std::vector< bool >::size_type n, std::vector< bool >::value_type x)
        """
        return _SimpleITK.VectorBool_insert(self, *args)

    def reserve(self, n):
        r"""reserve(VectorBool self, std::vector< bool >::size_type n)"""
        return _SimpleITK.VectorBool_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorBool self) -> std::vector< bool >::size_type"""
        return _SimpleITK.VectorBool_capacity(self)
    __swig_destroy__ = _SimpleITK.delete_VectorBool

# Register VectorBool in _SimpleITK:
_SimpleITK.VectorBool_swigregister(VectorBool)
class VectorUInt8(object):
    r"""Proxy of C++ std::vector< uint8_t > class."""

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

    def iterator(self):
        r"""iterator(VectorUInt8 self) -> SwigPyIterator"""
        return _SimpleITK.VectorUInt8_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorUInt8 self) -> bool"""
        return _SimpleITK.VectorUInt8___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorUInt8 self) -> bool"""
        return _SimpleITK.VectorUInt8___bool__(self)

    def __len__(self):
        r"""__len__(VectorUInt8 self) -> std::vector< unsigned char >::size_type"""
        return _SimpleITK.VectorUInt8___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(VectorUInt8 self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::difference_type j) -> VectorUInt8"""
        return _SimpleITK.VectorUInt8___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorUInt8 self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::difference_type j)
        __setslice__(VectorUInt8 self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::difference_type j, VectorUInt8 v)
        """
        return _SimpleITK.VectorUInt8___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(VectorUInt8 self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::difference_type j)"""
        return _SimpleITK.VectorUInt8___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorUInt8 self, std::vector< unsigned char >::difference_type i)
        __delitem__(VectorUInt8 self, SWIGPY_SLICEOBJECT * slice)
        """
        return _SimpleITK.VectorUInt8___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorUInt8 self, SWIGPY_SLICEOBJECT * slice) -> VectorUInt8
        __getitem__(VectorUInt8 self, std::vector< unsigned char >::difference_type i) -> std::vector< unsigned char >::value_type const &
        """
        return _SimpleITK.VectorUInt8___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorUInt8 self, SWIGPY_SLICEOBJECT * slice, VectorUInt8 v)
        __setitem__(VectorUInt8 self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(VectorUInt8 self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::value_type const & x)
        """
        return _SimpleITK.VectorUInt8___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorUInt8 self) -> std::vector< unsigned char >::value_type"""
        return _SimpleITK.VectorUInt8_pop(self)

    def append(self, x):
        r"""append(VectorUInt8 self, std::vector< unsigned char >::value_type const & x)"""
        return _SimpleITK.VectorUInt8_append(self, x)

    def empty(self):
        r"""empty(VectorUInt8 self) -> bool"""
        return _SimpleITK.VectorUInt8_empty(self)

    def size(self):
        r"""size(VectorUInt8 self) -> std::vector< unsigned char >::size_type"""
        return _SimpleITK.VectorUInt8_size(self)

    def swap(self, v):
        r"""swap(VectorUInt8 self, VectorUInt8 v)"""
        return _SimpleITK.VectorUInt8_swap(self, v)

    def begin(self):
        r"""begin(VectorUInt8 self) -> std::vector< unsigned char >::iterator"""
        return _SimpleITK.VectorUInt8_begin(self)

    def end(self):
        r"""end(VectorUInt8 self) -> std::vector< unsigned char >::iterator"""
        return _SimpleITK.VectorUInt8_end(self)

    def rbegin(self):
        r"""rbegin(VectorUInt8 self) -> std::vector< unsigned char >::reverse_iterator"""
        return _SimpleITK.VectorUInt8_rbegin(self)

    def rend(self):
        r"""rend(VectorUInt8 self) -> std::vector< unsigned char >::reverse_iterator"""
        return _SimpleITK.VectorUInt8_rend(self)

    def clear(self):
        r"""clear(VectorUInt8 self)"""
        return _SimpleITK.VectorUInt8_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorUInt8 self) -> std::vector< unsigned char >::allocator_type"""
        return _SimpleITK.VectorUInt8_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorUInt8 self)"""
        return _SimpleITK.VectorUInt8_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorUInt8 self, std::vector< unsigned char >::iterator pos) -> std::vector< unsigned char >::iterator
        erase(VectorUInt8 self, std::vector< unsigned char >::iterator first, std::vector< unsigned char >::iterator last) -> std::vector< unsigned char >::iterator
        """
        return _SimpleITK.VectorUInt8_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorUInt8 self) -> VectorUInt8
        __init__(VectorUInt8 self, VectorUInt8 other) -> VectorUInt8
        __init__(VectorUInt8 self, std::vector< unsigned char >::size_type size) -> VectorUInt8
        __init__(VectorUInt8 self, std::vector< unsigned char >::size_type size, std::vector< unsigned char >::value_type const & value) -> VectorUInt8
        """
        _SimpleITK.VectorUInt8_swiginit(self, _SimpleITK.new_VectorUInt8(*args))

    def push_back(self, x):
        r"""push_back(VectorUInt8 self, std::vector< unsigned char >::value_type const & x)"""
        return _SimpleITK.VectorUInt8_push_back(self, x)

    def front(self):
        r"""front(VectorUInt8 self) -> std::vector< unsigned char >::value_type const &"""
        return _SimpleITK.VectorUInt8_front(self)

    def back(self):
        r"""back(VectorUInt8 self) -> std::vector< unsigned char >::value_type const &"""
        return _SimpleITK.VectorUInt8_back(self)

    def assign(self, n, x):
        r"""assign(VectorUInt8 self, std::vector< unsigned char >::size_type n, std::vector< unsigned char >::value_type const & x)"""
        return _SimpleITK.VectorUInt8_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorUInt8 self, std::vector< unsigned char >::size_type new_size)
        resize(VectorUInt8 self, std::vector< unsigned char >::size_type new_size, std::vector< unsigned char >::value_type const & x)
        """
        return _SimpleITK.VectorUInt8_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorUInt8 self, std::vector< unsigned char >::iterator pos, std::vector< unsigned char >::value_type const & x) -> std::vector< unsigned char >::iterator
        insert(VectorUInt8 self, std::vector< unsigned char >::iterator pos, std::vector< unsigned char >::size_type n, std::vector< unsigned char >::value_type const & x)
        """
        return _SimpleITK.VectorUInt8_insert(self, *args)

    def reserve(self, n):
        r"""reserve(VectorUInt8 self, std::vector< unsigned char >::size_type n)"""
        return _SimpleITK.VectorUInt8_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorUInt8 self) -> std::vector< unsigned char >::size_type"""
        return _SimpleITK.VectorUInt8_capacity(self)
    __swig_destroy__ = _SimpleITK.delete_VectorUInt8

# Register VectorUInt8 in _SimpleITK:
_SimpleITK.VectorUInt8_swigregister(VectorUInt8)
class VectorInt8(object):
    r"""Proxy of C++ std::vector< int8_t > class."""

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

    def iterator(self):
        r"""iterator(VectorInt8 self) -> SwigPyIterator"""
        return _SimpleITK.VectorInt8_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorInt8 self) -> bool"""
        return _SimpleITK.VectorInt8___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorInt8 self) -> bool"""
        return _SimpleITK.VectorInt8___bool__(self)

    def __len__(self):
        r"""__len__(VectorInt8 self) -> std::vector< signed char >::size_type"""
        return _SimpleITK.VectorInt8___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(VectorInt8 self, std::vector< signed char >::difference_type i, std::vector< signed char >::difference_type j) -> VectorInt8"""
        return _SimpleITK.VectorInt8___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorInt8 self, std::vector< signed char >::difference_type i, std::vector< signed char >::difference_type j)
        __setslice__(VectorInt8 self, std::vector< signed char >::difference_type i, std::vector< signed char >::difference_type j, VectorInt8 v)
        """
        return _SimpleITK.VectorInt8___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(VectorInt8 self, std::vector< signed char >::difference_type i, std::vector< signed char >::difference_type j)"""
        return _SimpleITK.VectorInt8___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorInt8 self, std::vector< signed char >::difference_type i)
        __delitem__(VectorInt8 self, SWIGPY_SLICEOBJECT * slice)
        """
        return _SimpleITK.VectorInt8___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorInt8 self, SWIGPY_SLICEOBJECT * slice) -> VectorInt8
        __getitem__(VectorInt8 self, std::vector< signed char >::difference_type i) -> std::vector< signed char >::value_type const &
        """
        return _SimpleITK.VectorInt8___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorInt8 self, SWIGPY_SLICEOBJECT * slice, VectorInt8 v)
        __setitem__(VectorInt8 self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(VectorInt8 self, std::vector< signed char >::difference_type i, std::vector< signed char >::value_type const & x)
        """
        return _SimpleITK.VectorInt8___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorInt8 self) -> std::vector< signed char >::value_type"""
        return _SimpleITK.VectorInt8_pop(self)

    def append(self, x):
        r"""append(VectorInt8 self, std::vector< signed char >::value_type const & x)"""
        return _SimpleITK.VectorInt8_append(self, x)

    def empty(self):
        r"""empty(VectorInt8 self) -> bool"""
        return _SimpleITK.VectorInt8_empty(self)

    def size(self):
        r"""size(VectorInt8 self) -> std::vector< signed char >::size_type"""
        return _SimpleITK.VectorInt8_size(self)

    def swap(self, v):
        r"""swap(VectorInt8 self, VectorInt8 v)"""
        return _SimpleITK.VectorInt8_swap(self, v)

    def begin(self):
        r"""begin(VectorInt8 self) -> std::vector< signed char >::iterator"""
        return _SimpleITK.VectorInt8_begin(self)

    def end(self):
        r"""end(VectorInt8 self) -> std::vector< signed char >::iterator"""
        return _SimpleITK.VectorInt8_end(self)

    def rbegin(self):
        r"""rbegin(VectorInt8 self) -> std::vector< signed char >::reverse_iterator"""
        return _SimpleITK.VectorInt8_rbegin(self)

    def rend(self):
        r"""rend(VectorInt8 self) -> std::vector< signed char >::reverse_iterator"""
        return _SimpleITK.VectorInt8_rend(self)

    def clear(self):
        r"""clear(VectorInt8 self)"""
        return _SimpleITK.VectorInt8_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorInt8 self) -> std::vector< signed char >::allocator_type"""
        return _SimpleITK.VectorInt8_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorInt8 self)"""
        return _SimpleITK.VectorInt8_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorInt8 self, std::vector< signed char >::iterator pos) -> std::vector< signed char >::iterator
        erase(VectorInt8 self, std::vector< signed char >::iterator first, std::vector< signed char >::iterator last) -> std::vector< signed char >::iterator
        """
        return _SimpleITK.VectorInt8_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorInt8 self) -> VectorInt8
        __init__(VectorInt8 self, VectorInt8 other) -> VectorInt8
        __init__(VectorInt8 self, std::vector< signed char >::size_type size) -> VectorInt8
        __init__(VectorInt8 self, std::vector< signed char >::size_type size, std::vector< signed char >::value_type const & value) -> VectorInt8
        """
        _SimpleITK.VectorInt8_swiginit(self, _SimpleITK.new_VectorInt8(*args))

    def push_back(self, x):
        r"""push_back(VectorInt8 self, std::vector< signed char >::value_type const & x)"""
        return _SimpleITK.VectorInt8_push_back(self, x)

    def front(self):
        r"""front(VectorInt8 self) -> std::vector< signed char >::value_type const &"""
        return _SimpleITK.VectorInt8_front(self)

    def back(self):
        r"""back(VectorInt8 self) -> std::vector< signed char >::value_type const &"""
        return _SimpleITK.VectorInt8_back(self)

    def assign(self, n, x):
        r"""assign(VectorInt8 self, std::vector< signed char >::size_type n, std::vector< signed char >::value_type const & x)"""
        return _SimpleITK.VectorInt8_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorInt8 self, std::vector< signed char >::size_type new_size)
        resize(VectorInt8 self, std::vector< signed char >::size_type new_size, std::vector< signed char >::value_type const & x)
        """
        return _SimpleITK.VectorInt8_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorInt8 self, std::vector< signed char >::iterator pos, std::vector< signed char >::value_type const & x) -> std::vector< signed char >::iterator
        insert(VectorInt8 self, std::vector< signed char >::iterator pos, std::vector< signed char >::size_type n, std::vector< signed char >::value_type const & x)
        """
        return _SimpleITK.VectorInt8_insert(self, *args)

    def reserve(self, n):
        r"""reserve(VectorInt8 self, std::vector< signed char >::size_type n)"""
        return _SimpleITK.VectorInt8_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorInt8 self) -> std::vector< signed char >::size_type"""
        return _SimpleITK.VectorInt8_capacity(self)
    __swig_destroy__ = _SimpleITK.delete_VectorInt8

# Register VectorInt8 in _SimpleITK:
_SimpleITK.VectorInt8_swigregister(VectorInt8)
class VectorUInt16(object):
    r"""Proxy of C++ std::vector< uint16_t > class."""

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

    def iterator(self):
        r"""iterator(VectorUInt16 self) -> SwigPyIterator"""
        return _SimpleITK.VectorUInt16_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorUInt16 self) -> bool"""
        return _SimpleITK.VectorUInt16___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorUInt16 self) -> bool"""
        return _SimpleITK.VectorUInt16___bool__(self)

    def __len__(self):
        r"""__len__(VectorUInt16 self) -> std::vector< unsigned short >::size_type"""
        return _SimpleITK.VectorUInt16___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(VectorUInt16 self, std::vector< unsigned short >::difference_type i, std::vector< unsigned short >::difference_type j) -> VectorUInt16"""
        return _SimpleITK.VectorUInt16___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorUInt16 self, std::vector< unsigned short >::difference_type i, std::vector< unsigned short >::difference_type j)
        __setslice__(VectorUInt16 self, std::vector< unsigned short >::difference_type i, std::vector< unsigned short >::difference_type j, VectorUInt16 v)
        """
        return _SimpleITK.VectorUInt16___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(VectorUInt16 self, std::vector< unsigned short >::difference_type i, std::vector< unsigned short >::difference_type j)"""
        return _SimpleITK.VectorUInt16___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorUInt16 self, std::vector< unsigned short >::difference_type i)
        __delitem__(VectorUInt16 self, SWIGPY_SLICEOBJECT * slice)
        """
        return _SimpleITK.VectorUInt16___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorUInt16 self, SWIGPY_SLICEOBJECT * slice) -> VectorUInt16
        __getitem__(VectorUInt16 self, std::vector< unsigned short >::difference_type i) -> std::vector< unsigned short >::value_type const &
        """
        return _SimpleITK.VectorUInt16___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorUInt16 self, SWIGPY_SLICEOBJECT * slice, VectorUInt16 v)
        __setitem__(VectorUInt16 self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(VectorUInt16 self, std::vector< unsigned short >::difference_type i, std::vector< unsigned short >::value_type const & x)
        """
        return _SimpleITK.VectorUInt16___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorUInt16 self) -> std::vector< unsigned short >::value_type"""
        return _SimpleITK.VectorUInt16_pop(self)

    def append(self, x):
        r"""append(VectorUInt16 self, std::vector< unsigned short >::value_type const & x)"""
        return _SimpleITK.VectorUInt16_append(self, x)

    def empty(self):
        r"""empty(VectorUInt16 self) -> bool"""
        return _SimpleITK.VectorUInt16_empty(self)

    def size(self):
        r"""size(VectorUInt16 self) -> std::vector< unsigned short >::size_type"""
        return _SimpleITK.VectorUInt16_size(self)

    def swap(self, v):
        r"""swap(VectorUInt16 self, VectorUInt16 v)"""
        return _SimpleITK.VectorUInt16_swap(self, v)

    def begin(self):
        r"""begin(VectorUInt16 self) -> std::vector< unsigned short >::iterator"""
        return _SimpleITK.VectorUInt16_begin(self)

    def end(self):
        r"""end(VectorUInt16 self) -> std::vector< unsigned short >::iterator"""
        return _SimpleITK.VectorUInt16_end(self)

    def rbegin(self):
        r"""rbegin(VectorUInt16 self) -> std::vector< unsigned short >::reverse_iterator"""
        return _SimpleITK.VectorUInt16_rbegin(self)

    def rend(self):
        r"""rend(VectorUInt16 self) -> std::vector< unsigned short >::reverse_iterator"""
        return _SimpleITK.VectorUInt16_rend(self)

    def clear(self):
        r"""clear(VectorUInt16 self)"""
        return _SimpleITK.VectorUInt16_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorUInt16 self) -> std::vector< unsigned short >::allocator_type"""
        return _SimpleITK.VectorUInt16_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorUInt16 self)"""
        return _SimpleITK.VectorUInt16_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorUInt16 self, std::vector< unsigned short >::iterator pos) -> std::vector< unsigned short >::iterator
        erase(VectorUInt16 self, std::vector< unsigned short >::iterator first, std::vector< unsigned short >::iterator last) -> std::vector< unsigned short >::iterator
        """
        return _SimpleITK.VectorUInt16_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorUInt16 self) -> VectorUInt16
        __init__(VectorUInt16 self, VectorUInt16 other) -> VectorUInt16
        __init__(VectorUInt16 self, std::vector< unsigned short >::size_type size) -> VectorUInt16
        __init__(VectorUInt16 self, std::vector< unsigned short >::size_type size, std::vector< unsigned short >::value_type const & value) -> VectorUInt16
        """
        _SimpleITK.VectorUInt16_swiginit(self, _SimpleITK.new_VectorUInt16(*args))

    def push_back(self, x):
        r"""push_back(VectorUInt16 self, std::vector< unsigned short >::value_type const & x)"""
        return _SimpleITK.VectorUInt16_push_back(self, x)

    def front(self):
        r"""front(VectorUInt16 self) -> std::vector< unsigned short >::value_type const &"""
        return _SimpleITK.VectorUInt16_front(self)

    def back(self):
        r"""back(VectorUInt16 self) -> std::vector< unsigned short >::value_type const &"""
        return _SimpleITK.VectorUInt16_back(self)

    def assign(self, n, x):
        r"""assign(VectorUInt16 self, std::vector< unsigned short >::size_type n, std::vector< unsigned short >::value_type const & x)"""
        return _SimpleITK.VectorUInt16_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorUInt16 self, std::vector< unsigned short >::size_type new_size)
        resize(VectorUInt16 self, std::vector< unsigned short >::size_type new_size, std::vector< unsigned short >::value_type const & x)
        """
        return _SimpleITK.VectorUInt16_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorUInt16 self, std::vector< unsigned short >::iterator pos, std::vector< unsigned short >::value_type const & x) -> std::vector< unsigned short >::iterator
        insert(VectorUInt16 self, std::vector< unsigned short >::iterator pos, std::vector< unsigned short >::size_type n, std::vector< unsigned short >::value_type const & x)
        """
        return _SimpleITK.VectorUInt16_insert(self, *args)

    def reserve(self, n):
        r"""reserve(VectorUInt16 self, std::vector< unsigned short >::size_type n)"""
        return _SimpleITK.VectorUInt16_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorUInt16 self) -> std::vector< unsigned short >::size_type"""
        return _SimpleITK.VectorUInt16_capacity(self)
    __swig_destroy__ = _SimpleITK.delete_VectorUInt16

# Register VectorUInt16 in _SimpleITK:
_SimpleITK.VectorUInt16_swigregister(VectorUInt16)
class VectorInt16(object):
    r"""Proxy of C++ std::vector< int16_t > class."""

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

    def iterator(self):
        r"""iterator(VectorInt16 self) -> SwigPyIterator"""
        return _SimpleITK.VectorInt16_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorInt16 self) -> bool"""
        return _SimpleITK.VectorInt16___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorInt16 self) -> bool"""
        return _SimpleITK.VectorInt16___bool__(self)

    def __len__(self):
        r"""__len__(VectorInt16 self) -> std::vector< short >::size_type"""
        return _SimpleITK.VectorInt16___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(VectorInt16 self, std::vector< short >::difference_type i, std::vector< short >::difference_type j) -> VectorInt16"""
        return _SimpleITK.VectorInt16___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorInt16 self, std::vector< short >::difference_type i, std::vector< short >::difference_type j)
        __setslice__(VectorInt16 self, std::vector< short >::difference_type i, std::vector< short >::difference_type j, VectorInt16 v)
        """
        return _SimpleITK.VectorInt16___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(VectorInt16 self, std::vector< short >::difference_type i, std::vector< short >::difference_type j)"""
        return _SimpleITK.VectorInt16___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorInt16 self, std::vector< short >::difference_type i)
        __delitem__(VectorInt16 self, SWIGPY_SLICEOBJECT * slice)
        """
        return _SimpleITK.VectorInt16___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorInt16 self, SWIGPY_SLICEOBJECT * slice) -> VectorInt16
        __getitem__(VectorInt16 self, std::vector< short >::difference_type i) -> std::vector< short >::value_type const &
        """
        return _SimpleITK.VectorInt16___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorInt16 self, SWIGPY_SLICEOBJECT * slice, VectorInt16 v)
        __setitem__(VectorInt16 self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(VectorInt16 self, std::vector< short >::difference_type i, std::vector< short >::value_type const & x)
        """
        return _SimpleITK.VectorInt16___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorInt16 self) -> std::vector< short >::value_type"""
        return _SimpleITK.VectorInt16_pop(self)

    def append(self, x):
        r"""append(VectorInt16 self, std::vector< short >::value_type const & x)"""
        return _SimpleITK.VectorInt16_append(self, x)

    def empty(self):
        r"""empty(VectorInt16 self) -> bool"""
        return _SimpleITK.VectorInt16_empty(self)

    def size(self):
        r"""size(VectorInt16 self) -> std::vector< short >::size_type"""
        return _SimpleITK.VectorInt16_size(self)

    def swap(self, v):
        r"""swap(VectorInt16 self, VectorInt16 v)"""
        return _SimpleITK.VectorInt16_swap(self, v)

    def begin(self):
        r"""begin(VectorInt16 self) -> std::vector< short >::iterator"""
        return _SimpleITK.VectorInt16_begin(self)

    def end(self):
        r"""end(VectorInt16 self) -> std::vector< short >::iterator"""
        return _SimpleITK.VectorInt16_end(self)

    def rbegin(self):
        r"""rbegin(VectorInt16 self) -> std::vector< short >::reverse_iterator"""
        return _SimpleITK.VectorInt16_rbegin(self)

    def rend(self):
        r"""rend(VectorInt16 self) -> std::vector< short >::reverse_iterator"""
        return _SimpleITK.VectorInt16_rend(self)

    def clear(self):
        r"""clear(VectorInt16 self)"""
        return _SimpleITK.VectorInt16_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorInt16 self) -> std::vector< short >::allocator_type"""
        return _SimpleITK.VectorInt16_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorInt16 self)"""
        return _SimpleITK.VectorInt16_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorInt16 self, std::vector< short >::iterator pos) -> std::vector< short >::iterator
        erase(VectorInt16 self, std::vector< short >::iterator first, std::vector< short >::iterator last) -> std::vector< short >::iterator
        """
        return _SimpleITK.VectorInt16_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorInt16 self) -> VectorInt16
        __init__(VectorInt16 self, VectorInt16 other) -> VectorInt16
        __init__(VectorInt16 self, std::vector< short >::size_type size) -> VectorInt16
        __init__(VectorInt16 self, std::vector< short >::size_type size, std::vector< short >::value_type const & value) -> VectorInt16
        """
        _SimpleITK.VectorInt16_swiginit(self, _SimpleITK.new_VectorInt16(*args))

    def push_back(self, x):
        r"""push_back(VectorInt16 self, std::vector< short >::value_type const & x)"""
        return _SimpleITK.VectorInt16_push_back(self, x)

    def front(self):
        r"""front(VectorInt16 self) -> std::vector< short >::value_type const &"""
        return _SimpleITK.VectorInt16_front(self)

    def back(self):
        r"""back(VectorInt16 self) -> std::vector< short >::value_type const &"""
        return _SimpleITK.VectorInt16_back(self)

    def assign(self, n, x):
        r"""assign(VectorInt16 self, std::vector< short >::size_type n, std::vector< short >::value_type const & x)"""
        return _SimpleITK.VectorInt16_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorInt16 self, std::vector< short >::size_type new_size)
        resize(VectorInt16 self, std::vector< short >::size_type new_size, std::vector< short >::value_type const & x)
        """
        return _SimpleITK.VectorInt16_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorInt16 self, std::vector< short >::iterator pos, std::vector< short >::value_type const & x) -> std::vector< short >::iterator
        insert(VectorInt16 self, std::vector< short >::iterator pos, std::vector< short >::size_type n, std::vector< short >::value_type const & x)
        """
        return _SimpleITK.VectorInt16_insert(self, *args)

    def reserve(self, n):
        r"""reserve(VectorInt16 self, std::vector< short >::size_type n)"""
        return _SimpleITK.VectorInt16_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorInt16 self) -> std::vector< short >::size_type"""
        return _SimpleITK.VectorInt16_capacity(self)
    __swig_destroy__ = _SimpleITK.delete_VectorInt16

# Register VectorInt16 in _SimpleITK:
_SimpleITK.VectorInt16_swigregister(VectorInt16)
class VectorUInt32(object):
    r"""Proxy of C++ std::vector< uint32_t > class."""

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

    def iterator(self):
        r"""iterator(VectorUInt32 self) -> SwigPyIterator"""
        return _SimpleITK.VectorUInt32_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorUInt32 self) -> bool"""
        return _SimpleITK.VectorUInt32___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorUInt32 self) -> bool"""
        return _SimpleITK.VectorUInt32___bool__(self)

    def __len__(self):
        r"""__len__(VectorUInt32 self) -> std::vector< unsigned int >::size_type"""
        return _SimpleITK.VectorUInt32___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(VectorUInt32 self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j) -> VectorUInt32"""
        return _SimpleITK.VectorUInt32___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorUInt32 self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j)
        __setslice__(VectorUInt32 self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j, VectorUInt32 v)
        """
        return _SimpleITK.VectorUInt32___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(VectorUInt32 self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j)"""
        return _SimpleITK.VectorUInt32___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorUInt32 self, std::vector< unsigned int >::difference_type i)
        __delitem__(VectorUInt32 self, SWIGPY_SLICEOBJECT * slice)
        """
        return _SimpleITK.VectorUInt32___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorUInt32 self, SWIGPY_SLICEOBJECT * slice) -> VectorUInt32
        __getitem__(VectorUInt32 self, std::vector< unsigned int >::difference_type i) -> std::vector< unsigned int >::value_type const &
        """
        return _SimpleITK.VectorUInt32___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorUInt32 self, SWIGPY_SLICEOBJECT * slice, VectorUInt32 v)
        __setitem__(VectorUInt32 self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(VectorUInt32 self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::value_type const & x)
        """
        return _SimpleITK.VectorUInt32___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorUInt32 self) -> std::vector< unsigned int >::value_type"""
        return _SimpleITK.VectorUInt32_pop(self)

    def append(self, x):
        r"""append(VectorUInt32 self, std::vector< unsigned int >::value_type const & x)"""
        return _SimpleITK.VectorUInt32_append(self, x)

    def empty(self):
        r"""empty(VectorUInt32 self) -> bool"""
        return _SimpleITK.VectorUInt32_empty(self)

    def size(self):
        r"""size(VectorUInt32 self) -> std::vector< unsigned int >::size_type"""
        return _SimpleITK.VectorUInt32_size(self)

    def swap(self, v):
        r"""swap(VectorUInt32 self, VectorUInt32 v)"""
        return _SimpleITK.VectorUInt32_swap(self, v)

    def begin(self):
        r"""begin(VectorUInt32 self) -> std::vector< unsigned int >::iterator"""
        return _SimpleITK.VectorUInt32_begin(self)

    def end(self):
        r"""end(VectorUInt32 self) -> std::vector< unsigned int >::iterator"""
        return _SimpleITK.VectorUInt32_end(self)

    def rbegin(self):
        r"""rbegin(VectorUInt32 self) -> std::vector< unsigned int >::reverse_iterator"""
        return _SimpleITK.VectorUInt32_rbegin(self)

    def rend(self):
        r"""rend(VectorUInt32 self) -> std::vector< unsigned int >::reverse_iterator"""
        return _SimpleITK.VectorUInt32_rend(self)

    def clear(self):
        r"""clear(VectorUInt32 self)"""
        return _SimpleITK.VectorUInt32_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorUInt32 self) -> std::vector< unsigned int >::allocator_type"""
        return _SimpleITK.VectorUInt32_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorUInt32 self)"""
        return _SimpleITK.VectorUInt32_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorUInt32 self, std::vector< unsigned int >::iterator pos) -> std::vector< unsigned int >::iterator
        erase(VectorUInt32 self, std::vector< unsigned int >::iterator first, std::vector< unsigned int >::iterator last) -> std::vector< unsigned int >::iterator
        """
        return _SimpleITK.VectorUInt32_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorUInt32 self) -> VectorUInt32
        __init__(VectorUInt32 self, VectorUInt32 other) -> VectorUInt32
        __init__(VectorUInt32 self, std::vector< unsigned int >::size_type size) -> VectorUInt32
        __init__(VectorUInt32 self, std::vector< unsigned int >::size_type size, std::vector< unsigned int >::value_type const & value) -> VectorUInt32
        """
        _SimpleITK.VectorUInt32_swiginit(self, _SimpleITK.new_VectorUInt32(*args))

    def push_back(self, x):
        r"""push_back(VectorUInt32 self, std::vector< unsigned int >::value_type const & x)"""
        return _SimpleITK.VectorUInt32_push_back(self, x)

    def front(self):
        r"""front(VectorUInt32 self) -> std::vector< unsigned int >::value_type const &"""
        return _SimpleITK.VectorUInt32_front(self)

    def back(self):
        r"""back(VectorUInt32 self) -> std::vector< unsigned int >::value_type const &"""
        return _SimpleITK.VectorUInt32_back(self)

    def assign(self, n, x):
        r"""assign(VectorUInt32 self, std::vector< unsigned int >::size_type n, std::vector< unsigned int >::value_type const & x)"""
        return _SimpleITK.VectorUInt32_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorUInt32 self, std::vector< unsigned int >::size_type new_size)
        resize(VectorUInt32 self, std::vector< unsigned int >::size_type new_size, std::vector< unsigned int >::value_type const & x)
        """
        return _SimpleITK.VectorUInt32_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorUInt32 self, std::vector< unsigned int >::iterator pos, std::vector< unsigned int >::value_type const & x) -> std::vector< unsigned int >::iterator
        insert(VectorUInt32 self, std::vector< unsigned int >::iterator pos, std::vector< unsigned int >::size_type n, std::vector< unsigned int >::value_type const & x)
        """
        return _SimpleITK.VectorUInt32_insert(self, *args)

    def reserve(self, n):
        r"""reserve(VectorUInt32 self, std::vector< unsigned int >::size_type n)"""
        return _SimpleITK.VectorUInt32_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorUInt32 self) -> std::vector< unsigned int >::size_type"""
        return _SimpleITK.VectorUInt32_capacity(self)
    __swig_destroy__ = _SimpleITK.delete_VectorUInt32

# Register VectorUInt32 in _SimpleITK:
_SimpleITK.VectorUInt32_swigregister(VectorUInt32)
class VectorInt32(object):
    r"""Proxy of C++ std::vector< int32_t > class."""

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

    def iterator(self):
        r"""iterator(VectorInt32 self) -> SwigPyIterator"""
        return _SimpleITK.VectorInt32_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorInt32 self) -> bool"""
        return _SimpleITK.VectorInt32___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorInt32 self) -> bool"""
        return _SimpleITK.VectorInt32___bool__(self)

    def __len__(self):
        r"""__len__(VectorInt32 self) -> std::vector< int >::size_type"""
        return _SimpleITK.VectorInt32___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(VectorInt32 self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> VectorInt32"""
        return _SimpleITK.VectorInt32___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorInt32 self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)
        __setslice__(VectorInt32 self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, VectorInt32 v)
        """
        return _SimpleITK.VectorInt32___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(VectorInt32 self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"""
        return _SimpleITK.VectorInt32___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorInt32 self, std::vector< int >::difference_type i)
        __delitem__(VectorInt32 self, SWIGPY_SLICEOBJECT * slice)
        """
        return _SimpleITK.VectorInt32___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorInt32 self, SWIGPY_SLICEOBJECT * slice) -> VectorInt32
        __getitem__(VectorInt32 self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
        """
        return _SimpleITK.VectorInt32___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorInt32 self, SWIGPY_SLICEOBJECT * slice, VectorInt32 v)
        __setitem__(VectorInt32 self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(VectorInt32 self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)
        """
        return _SimpleITK.VectorInt32___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorInt32 self) -> std::vector< int >::value_type"""
        return _SimpleITK.VectorInt32_pop(self)

    def append(self, x):
        r"""append(VectorInt32 self, std::vector< int >::value_type const & x)"""
        return _SimpleITK.VectorInt32_append(self, x)

    def empty(self):
        r"""empty(VectorInt32 self) -> bool"""
        return _SimpleITK.VectorInt32_empty(self)

    def size(self):
        r"""size(VectorInt32 self) -> std::vector< int >::size_type"""
        return _SimpleITK.VectorInt32_size(self)

    def swap(self, v):
        r"""swap(VectorInt32 self, VectorInt32 v)"""
        return _SimpleITK.VectorInt32_swap(self, v)

    def begin(self):
        r"""begin(VectorInt32 self) -> std::vector< int >::iterator"""
        return _SimpleITK.VectorInt32_begin(self)

    def end(self):
        r"""end(VectorInt32 self) -> std::vector< int >::iterator"""
        return _SimpleITK.VectorInt32_end(self)

    def rbegin(self):
        r"""rbegin(VectorInt32 self) -> std::vector< int >::reverse_iterator"""
        return _SimpleITK.VectorInt32_rbegin(self)

    def rend(self):
        r"""rend(VectorInt32 self) -> std::vector< int >::reverse_iterator"""
        return _SimpleITK.VectorInt32_rend(self)

    def clear(self):
        r"""clear(VectorInt32 self)"""
        return _SimpleITK.VectorInt32_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorInt32 self) -> std::vector< int >::allocator_type"""
        return _SimpleITK.VectorInt32_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorInt32 self)"""
        return _SimpleITK.VectorInt32_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorInt32 self, std::vector< int >::iterator pos) -> std::vector< int >::iterator
        erase(VectorInt32 self, std::vector< int >::iterator first, std::vector< int >::iterator last) -> std::vector< int >::iterator
        """
        return _SimpleITK.VectorInt32_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorInt32 self) -> VectorInt32
        __init__(VectorInt32 self, VectorInt32 other) -> VectorInt32
        __init__(VectorInt32 self, std::vector< int >::size_type size) -> VectorInt32
        __init__(VectorInt32 self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> VectorInt32
        """
        _SimpleITK.VectorInt32_swiginit(self, _SimpleITK.new_VectorInt32(*args))

    def push_back(self, x):
        r"""push_back(VectorInt32 self, std::vector< int >::value_type const & x)"""
        return _SimpleITK.VectorInt32_push_back(self, x)

    def front(self):
        r"""front(VectorInt32 self) -> std::vector< int >::value_type const &"""
        return _SimpleITK.VectorInt32_front(self)

    def back(self):
        r"""back(VectorInt32 self) -> std::vector< int >::value_type const &"""
        return _SimpleITK.VectorInt32_back(self)

    def assign(self, n, x):
        r"""assign(VectorInt32 self, std::vector< int >::size_type n, std::vector< int >::value_type const & x)"""
        return _SimpleITK.VectorInt32_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorInt32 self, std::vector< int >::size_type new_size)
        resize(VectorInt32 self, std::vector< int >::size_type new_size, std::vector< int >::value_type const & x)
        """
        return _SimpleITK.VectorInt32_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorInt32 self, std::vector< int >::iterator pos, std::vector< int >::value_type const & x) -> std::vector< int >::iterator
        insert(VectorInt32 self, std::vector< int >::iterator pos, std::vector< int >::size_type n, std::vector< int >::value_type const & x)
        """
        return _SimpleITK.VectorInt32_insert(self, *args)

    def reserve(self, n):
        r"""reserve(VectorInt32 self, std::vector< int >::size_type n)"""
        return _SimpleITK.VectorInt32_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorInt32 self) -> std::vector< int >::size_type"""
        return _SimpleITK.VectorInt32_capacity(self)
    __swig_destroy__ = _SimpleITK.delete_VectorInt32

# Register VectorInt32 in _SimpleITK:
_SimpleITK.VectorInt32_swigregister(VectorInt32)
class VectorUInt64(object):
    r"""Proxy of C++ std::vector< uint64_t > class."""

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

    def iterator(self):
        r"""iterator(VectorUInt64 self) -> SwigPyIterator"""
        return _SimpleITK.VectorUInt64_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorUInt64 self) -> bool"""
        return _SimpleITK.VectorUInt64___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorUInt64 self) -> bool"""
        return _SimpleITK.VectorUInt64___bool__(self)

    def __len__(self):
        r"""__len__(VectorUInt64 self) -> std::vector< unsigned long >::size_type"""
        return _SimpleITK.VectorUInt64___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(VectorUInt64 self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j) -> VectorUInt64"""
        return _SimpleITK.VectorUInt64___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorUInt64 self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)
        __setslice__(VectorUInt64 self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j, VectorUInt64 v)
        """
        return _SimpleITK.VectorUInt64___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(VectorUInt64 self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)"""
        return _SimpleITK.VectorUInt64___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorUInt64 self, std::vector< unsigned long >::difference_type i)
        __delitem__(VectorUInt64 self, SWIGPY_SLICEOBJECT * slice)
        """
        return _SimpleITK.VectorUInt64___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorUInt64 self, SWIGPY_SLICEOBJECT * slice) -> VectorUInt64
        __getitem__(VectorUInt64 self, std::vector< unsigned long >::difference_type i) -> std::vector< unsigned long >::value_type const &
        """
        return _SimpleITK.VectorUInt64___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorUInt64 self, SWIGPY_SLICEOBJECT * slice, VectorUInt64 v)
        __setitem__(VectorUInt64 self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(VectorUInt64 self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::value_type const & x)
        """
        return _SimpleITK.VectorUInt64___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorUInt64 self) -> std::vector< unsigned long >::value_type"""
        return _SimpleITK.VectorUInt64_pop(self)

    def append(self, x):
        r"""append(VectorUInt64 self, std::vector< unsigned long >::value_type const & x)"""
        return _SimpleITK.VectorUInt64_append(self, x)

    def empty(self):
        r"""empty(VectorUInt64 self) -> bool"""
        return _SimpleITK.VectorUInt64_empty(self)

    def size(self):
        r"""size(VectorUInt64 self) -> std::vector< unsigned long >::size_type"""
        return _SimpleITK.VectorUInt64_size(self)

    def swap(self, v):
        r"""swap(VectorUInt64 self, VectorUInt64 v)"""
        return _SimpleITK.VectorUInt64_swap(self, v)

    def begin(self):
        r"""begin(VectorUInt64 self) -> std::vector< unsigned long >::iterator"""
        return _SimpleITK.VectorUInt64_begin(self)

    def end(self):
        r"""end(VectorUInt64 self) -> std::vector< unsigned long >::iterator"""
        return _SimpleITK.VectorUInt64_end(self)

    def rbegin(self):
        r"""rbegin(VectorUInt64 self) -> std::vector< unsigned long >::reverse_iterator"""
        return _SimpleITK.VectorUInt64_rbegin(self)

    def rend(self):
        r"""rend(VectorUInt64 self) -> std::vector< unsigned long >::reverse_iterator"""
        return _SimpleITK.VectorUInt64_rend(self)

    def clear(self):
        r"""clear(VectorUInt64 self)"""
        return _SimpleITK.VectorUInt64_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorUInt64 self) -> std::vector< unsigned long >::allocator_type"""
        return _SimpleITK.VectorUInt64_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorUInt64 self)"""
        return _SimpleITK.VectorUInt64_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorUInt64 self, std::vector< unsigned long >::iterator pos) -> std::vector< unsigned long >::iterator
        erase(VectorUInt64 self, std::vector< unsigned long >::iterator first, std::vector< unsigned long >::iterator last) -> std::vector< unsigned long >::iterator
        """
        return _SimpleITK.VectorUInt64_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorUInt64 self) -> VectorUInt64
        __init__(VectorUInt64 self, VectorUInt64 other) -> VectorUInt64
        __init__(VectorUInt64 self, std::vector< unsigned long >::size_type size) -> VectorUInt64
        __init__(VectorUInt64 self, std::vector< unsigned long >::size_type size, std::vector< unsigned long >::value_type const & value) -> VectorUInt64
        """
        _SimpleITK.VectorUInt64_swiginit(self, _SimpleITK.new_VectorUInt64(*args))

    def push_back(self, x):
        r"""push_back(VectorUInt64 self, std::vector< unsigned long >::value_type const & x)"""
        return _SimpleITK.VectorUInt64_push_back(self, x)

    def front(self):
        r"""front(VectorUInt64 self) -> std::vector< unsigned long >::value_type const &"""
        return _SimpleITK.VectorUInt64_front(self)

    def back(self):
        r"""back(VectorUInt64 self) -> std::vector< unsigned long >::value_type const &"""
        return _SimpleITK.VectorUInt64_back(self)

    def assign(self, n, x):
        r"""assign(VectorUInt64 self, std::vector< unsigned long >::size_type n, std::vector< unsigned long >::value_type const & x)"""
        return _SimpleITK.VectorUInt64_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorUInt64 self, std::vector< unsigned long >::size_type new_size)
        resize(VectorUInt64 self, std::vector< unsigned long >::size_type new_size, std::vector< unsigned long >::value_type const & x)
        """
        return _SimpleITK.VectorUInt64_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorUInt64 self, std::vector< unsigned long >::iterator pos, std::vector< unsigned long >::value_type const & x) -> std::vector< unsigned long >::iterator
        insert(VectorUInt64 self, std::vector< unsigned long >::iterator pos, std::vector< unsigned long >::size_type n, std::vector< unsigned long >::value_type const & x)
        """
        return _SimpleITK.VectorUInt64_insert(self, *args)

    def reserve(self, n):
        r"""reserve(VectorUInt64 self, std::vector< unsigned long >::size_type n)"""
        return _SimpleITK.VectorUInt64_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorUInt64 self) -> std::vector< unsigned long >::size_type"""
        return _SimpleITK.VectorUInt64_capacity(self)
    __swig_destroy__ = _SimpleITK.delete_VectorUInt64

# Register VectorUInt64 in _SimpleITK:
_SimpleITK.VectorUInt64_swigregister(VectorUInt64)
class VectorInt64(object):
    r"""Proxy of C++ std::vector< int64_t > class."""

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

    def iterator(self):
        r"""iterator(VectorInt64 self) -> SwigPyIterator"""
        return _SimpleITK.VectorInt64_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorInt64 self) -> bool"""
        return _SimpleITK.VectorInt64___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorInt64 self) -> bool"""
        return _SimpleITK.VectorInt64___bool__(self)

    def __len__(self):
        r"""__len__(VectorInt64 self) -> std::vector< long >::size_type"""
        return _SimpleITK.VectorInt64___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(VectorInt64 self, std::vector< long >::difference_type i, std::vector< long >::difference_type j) -> VectorInt64"""
        return _SimpleITK.VectorInt64___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorInt64 self, std::vector< long >::difference_type i, std::vector< long >::difference_type j)
        __setslice__(VectorInt64 self, std::vector< long >::difference_type i, std::vector< long >::difference_type j, VectorInt64 v)
        """
        return _SimpleITK.VectorInt64___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(VectorInt64 self, std::vector< long >::difference_type i, std::vector< long >::difference_type j)"""
        return _SimpleITK.VectorInt64___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorInt64 self, std::vector< long >::difference_type i)
        __delitem__(VectorInt64 self, SWIGPY_SLICEOBJECT * slice)
        """
        return _SimpleITK.VectorInt64___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorInt64 self, SWIGPY_SLICEOBJECT * slice) -> VectorInt64
        __getitem__(VectorInt64 self, std::vector< long >::difference_type i) -> std::vector< long >::value_type const &
        """
        return _SimpleITK.VectorInt64___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorInt64 self, SWIGPY_SLICEOBJECT * slice, VectorInt64 v)
        __setitem__(VectorInt64 self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(VectorInt64 self, std::vector< long >::difference_type i, std::vector< long >::value_type const & x)
        """
        return _SimpleITK.VectorInt64___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorInt64 self) -> std::vector< long >::value_type"""
        return _SimpleITK.VectorInt64_pop(self)

    def append(self, x):
        r"""append(VectorInt64 self, std::vector< long >::value_type const & x)"""
        return _SimpleITK.VectorInt64_append(self, x)

    def empty(self):
        r"""empty(VectorInt64 self) -> bool"""
        return _SimpleITK.VectorInt64_empty(self)

    def size(self):
        r"""size(VectorInt64 self) -> std::vector< long >::size_type"""
        return _SimpleITK.VectorInt64_size(self)

    def swap(self, v):
        r"""swap(VectorInt64 self, VectorInt64 v)"""
        return _SimpleITK.VectorInt64_swap(self, v)

    def begin(self):
        r"""begin(VectorInt64 self) -> std::vector< long >::iterator"""
        return _SimpleITK.VectorInt64_begin(self)

    def end(self):
        r"""end(VectorInt64 self) -> std::vector< long >::iterator"""
        return _SimpleITK.VectorInt64_end(self)

    def rbegin(self):
        r"""rbegin(VectorInt64 self) -> std::vector< long >::reverse_iterator"""
        return _SimpleITK.VectorInt64_rbegin(self)

    def rend(self):
        r"""rend(VectorInt64 self) -> std::vector< long >::reverse_iterator"""
        return _SimpleITK.VectorInt64_rend(self)

    def clear(self):
        r"""clear(VectorInt64 self)"""
        return _SimpleITK.VectorInt64_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorInt64 self) -> std::vector< long >::allocator_type"""
        return _SimpleITK.VectorInt64_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorInt64 self)"""
        return _SimpleITK.VectorInt64_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorInt64 self, std::vector< long >::iterator pos) -> std::vector< long >::iterator
        erase(VectorInt64 self, std::vector< long >::iterator first, std::vector< long >::iterator last) -> std::vector< long >::iterator
        """
        return _SimpleITK.VectorInt64_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorInt64 self) -> VectorInt64
        __init__(VectorInt64 self, VectorInt64 other) -> VectorInt64
        __init__(VectorInt64 self, std::vector< long >::size_type size) -> VectorInt64
        __init__(VectorInt64 self, std::vector< long >::size_type size, std::vector< long >::value_type const & value) -> VectorInt64
        """
        _SimpleITK.VectorInt64_swiginit(self, _SimpleITK.new_VectorInt64(*args))

    def push_back(self, x):
        r"""push_back(VectorInt64 self, std::vector< long >::value_type const & x)"""
        return _SimpleITK.VectorInt64_push_back(self, x)

    def front(self):
        r"""front(VectorInt64 self) -> std::vector< long >::value_type const &"""
        return _SimpleITK.VectorInt64_front(self)

    def back(self):
        r"""back(VectorInt64 self) -> std::vector< long >::value_type const &"""
        return _SimpleITK.VectorInt64_back(self)

    def assign(self, n, x):
        r"""assign(VectorInt64 self, std::vector< long >::size_type n, std::vector< long >::value_type const & x)"""
        return _SimpleITK.VectorInt64_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorInt64 self, std::vector< long >::size_type new_size)
        resize(VectorInt64 self, std::vector< long >::size_type new_size, std::vector< long >::value_type const & x)
        """
        return _SimpleITK.VectorInt64_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorInt64 self, std::vector< long >::iterator pos, std::vector< long >::value_type const & x) -> std::vector< long >::iterator
        insert(VectorInt64 self, std::vector< long >::iterator pos, std::vector< long >::size_type n, std::vector< long >::value_type const & x)
        """
        return _SimpleITK.VectorInt64_insert(self, *args)

    def reserve(self, n):
        r"""reserve(VectorInt64 self, std::vector< long >::size_type n)"""
        return _SimpleITK.VectorInt64_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorInt64 self) -> std::vector< long >::size_type"""
        return _SimpleITK.VectorInt64_capacity(self)
    __swig_destroy__ = _SimpleITK.delete_VectorInt64

# Register VectorInt64 in _SimpleITK:
_SimpleITK.VectorInt64_swigregister(VectorInt64)
class VectorFloat(object):
    r"""Proxy of C++ std::vector< float > class."""

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

    def iterator(self):
        r"""iterator(VectorFloat self) -> SwigPyIterator"""
        return _SimpleITK.VectorFloat_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorFloat self) -> bool"""
        return _SimpleITK.VectorFloat___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorFloat self) -> bool"""
        return _SimpleITK.VectorFloat___bool__(self)

    def __len__(self):
        r"""__len__(VectorFloat self) -> std::vector< float >::size_type"""
        return _SimpleITK.VectorFloat___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(VectorFloat self, std::vector< float >::difference_type i, std::vector< float >::difference_type j) -> VectorFloat"""
        return _SimpleITK.VectorFloat___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorFloat self, std::vector< float >::difference_type i, std::vector< float >::difference_type j)
        __setslice__(VectorFloat self, std::vector< float >::difference_type i, std::vector< float >::difference_type j, VectorFloat v)
        """
        return _SimpleITK.VectorFloat___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(VectorFloat self, std::vector< float >::difference_type i, std::vector< float >::difference_type j)"""
        return _SimpleITK.VectorFloat___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorFloat self, std::vector< float >::difference_type i)
        __delitem__(VectorFloat self, SWIGPY_SLICEOBJECT * slice)
        """
        return _SimpleITK.VectorFloat___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorFloat self, SWIGPY_SLICEOBJECT * slice) -> VectorFloat
        __getitem__(VectorFloat self, std::vector< float >::difference_type i) -> std::vector< float >::value_type const &
        """
        return _SimpleITK.VectorFloat___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorFloat self, SWIGPY_SLICEOBJECT * slice, VectorFloat v)
        __setitem__(VectorFloat self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(VectorFloat self, std::vector< float >::difference_type i, std::vector< float >::value_type const & x)
        """
        return _SimpleITK.VectorFloat___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorFloat self) -> std::vector< float >::value_type"""
        return _SimpleITK.VectorFloat_pop(self)

    def append(self, x):
        r"""append(VectorFloat self, std::vector< float >::value_type const & x)"""
        return _SimpleITK.VectorFloat_append(self, x)

    def empty(self):
        r"""empty(VectorFloat self) -> bool"""
        return _SimpleITK.VectorFloat_empty(self)

    def size(self):
        r"""size(VectorFloat self) -> std::vector< float >::size_type"""
        return _SimpleITK.VectorFloat_size(self)

    def swap(self, v):
        r"""swap(VectorFloat self, VectorFloat v)"""
        return _SimpleITK.VectorFloat_swap(self, v)

    def begin(self):
        r"""begin(VectorFloat self) -> std::vector< float >::iterator"""
        return _SimpleITK.VectorFloat_begin(self)

    def end(self):
        r"""end(VectorFloat self) -> std::vector< float >::iterator"""
        return _SimpleITK.VectorFloat_end(self)

    def rbegin(self):
        r"""rbegin(VectorFloat self) -> std::vector< float >::reverse_iterator"""
        return _SimpleITK.VectorFloat_rbegin(self)

    def rend(self):
        r"""rend(VectorFloat self) -> std::vector< float >::reverse_iterator"""
        return _SimpleITK.VectorFloat_rend(self)

    def clear(self):
        r"""clear(VectorFloat self)"""
        return _SimpleITK.VectorFloat_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorFloat self) -> std::vector< float >::allocator_type"""
        return _SimpleITK.VectorFloat_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorFloat self)"""
        return _SimpleITK.VectorFloat_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorFloat self, std::vector< float >::iterator pos) -> std::vector< float >::iterator
        erase(VectorFloat self, std::vector< float >::iterator first, std::vector< float >::iterator last) -> std::vector< float >::iterator
        """
        return _SimpleITK.VectorFloat_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorFloat self) -> VectorFloat
        __init__(VectorFloat self, VectorFloat other) -> VectorFloat
        __init__(VectorFloat self, std::vector< float >::size_type size) -> VectorFloat
        __init__(VectorFloat self, std::vector< float >::size_type size, std::vector< float >::value_type const & value) -> VectorFloat
        """
        _SimpleITK.VectorFloat_swiginit(self, _SimpleITK.new_VectorFloat(*args))

    def push_back(self, x):
        r"""push_back(VectorFloat self, std::vector< float >::value_type const & x)"""
        return _SimpleITK.VectorFloat_push_back(self, x)

    def front(self):
        r"""front(VectorFloat self) -> std::vector< float >::value_type const &"""
        return _SimpleITK.VectorFloat_front(self)

    def back(self):
        r"""back(VectorFloat self) -> std::vector< float >::value_type const &"""
        return _SimpleITK.VectorFloat_back(self)

    def assign(self, n, x):
        r"""assign(VectorFloat self, std::vector< float >::size_type n, std::vector< float >::value_type const & x)"""
        return _SimpleITK.VectorFloat_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorFloat self, std::vector< float >::size_type new_size)
        resize(VectorFloat self, std::vector< float >::size_type new_size, std::vector< float >::value_type const & x)
        """
        return _SimpleITK.VectorFloat_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorFloat self, std::vector< float >::iterator pos, std::vector< float >::value_type const & x) -> std::vector< float >::iterator
        insert(VectorFloat self, std::vector< float >::iterator pos, std::vector< float >::size_type n, std::vector< float >::value_type const & x)
        """
        return _SimpleITK.VectorFloat_insert(self, *args)

    def reserve(self, n):
        r"""reserve(VectorFloat self, std::vector< float >::size_type n)"""
        return _SimpleITK.VectorFloat_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorFloat self) -> std::vector< float >::size_type"""
        return _SimpleITK.VectorFloat_capacity(self)
    __swig_destroy__ = _SimpleITK.delete_VectorFloat

# Register VectorFloat in _SimpleITK:
_SimpleITK.VectorFloat_swigregister(VectorFloat)
class VectorDouble(object):
    r"""Proxy of C++ std::vector< double > class."""

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

    def iterator(self):
        r"""iterator(VectorDouble self) -> SwigPyIterator"""
        return _SimpleITK.VectorDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorDouble self) -> bool"""
        return _SimpleITK.VectorDouble___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorDouble self) -> bool"""
        return _SimpleITK.VectorDouble___bool__(self)

    def __len__(self):
        r"""__len__(VectorDouble self) -> std::vector< double >::size_type"""
        return _SimpleITK.VectorDouble___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(VectorDouble self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> VectorDouble"""
        return _SimpleITK.VectorDouble___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorDouble self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)
        __setslice__(VectorDouble self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, VectorDouble v)
        """
        return _SimpleITK.VectorDouble___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(VectorDouble self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"""
        return _SimpleITK.VectorDouble___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorDouble self, std::vector< double >::difference_type i)
        __delitem__(VectorDouble self, SWIGPY_SLICEOBJECT * slice)
        """
        return _SimpleITK.VectorDouble___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorDouble self, SWIGPY_SLICEOBJECT * slice) -> VectorDouble
        __getitem__(VectorDouble self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &
        """
        return _SimpleITK.VectorDouble___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorDouble self, SWIGPY_SLICEOBJECT * slice, VectorDouble v)
        __setitem__(VectorDouble self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(VectorDouble self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)
        """
        return _SimpleITK.VectorDouble___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorDouble self) -> std::vector< double >::value_type"""
        return _SimpleITK.VectorDouble_pop(self)

    def append(self, x):
        r"""append(VectorDouble self, std::vector< double >::value_type const & x)"""
        return _SimpleITK.VectorDouble_append(self, x)

    def empty(self):
        r"""empty(VectorDouble self) -> bool"""
        return _SimpleITK.VectorDouble_empty(self)

    def size(self):
        r"""size(VectorDouble self) -> std::vector< double >::size_type"""
        return _SimpleITK.VectorDouble_size(self)

    def swap(self, v):
        r"""swap(VectorDouble self, VectorDouble v)"""
        return _SimpleITK.VectorDouble_swap(self, v)

    def begin(self):
        r"""begin(VectorDouble self) -> std::vector< double >::iterator"""
        return _SimpleITK.VectorDouble_begin(self)

    def end(self):
        r"""end(VectorDouble self) -> std::vector< double >::iterator"""
        return _SimpleITK.VectorDouble_end(self)

    def rbegin(self):
        r"""rbegin(VectorDouble self) -> std::vector< double >::reverse_iterator"""
        return _SimpleITK.VectorDouble_rbegin(self)

    def rend(self):
        r"""rend(VectorDouble self) -> std::vector< double >::reverse_iterator"""
        return _SimpleITK.VectorDouble_rend(self)

    def clear(self):
        r"""clear(VectorDouble self)"""
        return _SimpleITK.VectorDouble_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorDouble self) -> std::vector< double >::allocator_type"""
        return _SimpleITK.VectorDouble_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorDouble self)"""
        return _SimpleITK.VectorDouble_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorDouble self, std::vector< double >::iterator pos) -> std::vector< double >::iterator
        erase(VectorDouble self, std::vector< double >::iterator first, std::vector< double >::iterator last) -> std::vector< double >::iterator
        """
        return _SimpleITK.VectorDouble_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorDouble self) -> VectorDouble
        __init__(VectorDouble self, VectorDouble other) -> VectorDouble
        __init__(VectorDouble self, std::vector< double >::size_type size) -> VectorDouble
        __init__(VectorDouble self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> VectorDouble
        """
        _SimpleITK.VectorDouble_swiginit(self, _SimpleITK.new_VectorDouble(*args))

    def push_back(self, x):
        r"""push_back(VectorDouble self, std::vector< double >::value_type const & x)"""
        return _SimpleITK.VectorDouble_push_back(self, x)

    def front(self):
        r"""front(VectorDouble self) -> std::vector< double >::value_type const &"""
        return _SimpleITK.VectorDouble_front(self)

    def back(self):
        r"""back(VectorDouble self) -> std::vector< double >::value_type const &"""
        return _SimpleITK.VectorDouble_back(self)

    def assign(self, n, x):
        r"""assign(VectorDouble self, std::vector< double >::size_type n, std::vector< double >::value_type const & x)"""
        return _SimpleITK.VectorDouble_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorDouble self, std::vector< double >::size_type new_size)
        resize(VectorDouble self, std::vector< double >::size_type new_size, std::vector< double >::value_type const & x)
        """
        return _SimpleITK.VectorDouble_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorDouble self, std::vector< double >::iterator pos, std::vector< double >::value_type const & x) -> std::vector< double >::iterator
        insert(VectorDouble self, std::vector< double >::iterator pos, std::vector< double >::size_type n, std::vector< double >::value_type const & x)
        """
        return _SimpleITK.VectorDouble_insert(self, *args)

    def reserve(self, n):
        r"""reserve(VectorDouble self, std::vector< double >::size_type n)"""
        return _SimpleITK.VectorDouble_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorDouble self) -> std::vector< double >::size_type"""
        return _SimpleITK.VectorDouble_capacity(self)
    __swig_destroy__ = _SimpleITK.delete_VectorDouble

# Register VectorDouble in _SimpleITK:
_SimpleITK.VectorDouble_swigregister(VectorDouble)
class VectorOfImage(object):
    r"""Proxy of C++ std::vector< slicer_itk::simple::Image > class."""

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

    def iterator(self):
        r"""iterator(VectorOfImage self) -> SwigPyIterator"""
        return _SimpleITK.VectorOfImage_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorOfImage self) -> bool"""
        return _SimpleITK.VectorOfImage___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorOfImage self) -> bool"""
        return _SimpleITK.VectorOfImage___bool__(self)

    def __len__(self):
        r"""__len__(VectorOfImage self) -> std::vector< slicer_itk::simple::Image >::size_type"""
        return _SimpleITK.VectorOfImage___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(VectorOfImage self, std::vector< slicer_itk::simple::Image >::difference_type i, std::vector< slicer_itk::simple::Image >::difference_type j) -> VectorOfImage"""
        return _SimpleITK.VectorOfImage___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorOfImage self, std::vector< slicer_itk::simple::Image >::difference_type i, std::vector< slicer_itk::simple::Image >::difference_type j)
        __setslice__(VectorOfImage self, std::vector< slicer_itk::simple::Image >::difference_type i, std::vector< slicer_itk::simple::Image >::difference_type j, VectorOfImage v)
        """
        return _SimpleITK.VectorOfImage___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(VectorOfImage self, std::vector< slicer_itk::simple::Image >::difference_type i, std::vector< slicer_itk::simple::Image >::difference_type j)"""
        return _SimpleITK.VectorOfImage___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorOfImage self, std::vector< slicer_itk::simple::Image >::difference_type i)
        __delitem__(VectorOfImage self, SWIGPY_SLICEOBJECT * slice)
        """
        return _SimpleITK.VectorOfImage___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorOfImage self, SWIGPY_SLICEOBJECT * slice) -> VectorOfImage
        __getitem__(VectorOfImage self, std::vector< slicer_itk::simple::Image >::difference_type i) -> Image
        """
        return _SimpleITK.VectorOfImage___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorOfImage self, SWIGPY_SLICEOBJECT * slice, VectorOfImage v)
        __setitem__(VectorOfImage self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(VectorOfImage self, std::vector< slicer_itk::simple::Image >::difference_type i, Image x)
        """
        return _SimpleITK.VectorOfImage___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorOfImage self) -> Image"""
        return _SimpleITK.VectorOfImage_pop(self)

    def append(self, x):
        r"""append(VectorOfImage self, Image x)"""
        return _SimpleITK.VectorOfImage_append(self, x)

    def empty(self):
        r"""empty(VectorOfImage self) -> bool"""
        return _SimpleITK.VectorOfImage_empty(self)

    def size(self):
        r"""size(VectorOfImage self) -> std::vector< slicer_itk::simple::Image >::size_type"""
        return _SimpleITK.VectorOfImage_size(self)

    def swap(self, v):
        r"""swap(VectorOfImage self, VectorOfImage v)"""
        return _SimpleITK.VectorOfImage_swap(self, v)

    def begin(self):
        r"""begin(VectorOfImage self) -> std::vector< slicer_itk::simple::Image >::iterator"""
        return _SimpleITK.VectorOfImage_begin(self)

    def end(self):
        r"""end(VectorOfImage self) -> std::vector< slicer_itk::simple::Image >::iterator"""
        return _SimpleITK.VectorOfImage_end(self)

    def rbegin(self):
        r"""rbegin(VectorOfImage self) -> std::vector< slicer_itk::simple::Image >::reverse_iterator"""
        return _SimpleITK.VectorOfImage_rbegin(self)

    def rend(self):
        r"""rend(VectorOfImage self) -> std::vector< slicer_itk::simple::Image >::reverse_iterator"""
        return _SimpleITK.VectorOfImage_rend(self)

    def clear(self):
        r"""clear(VectorOfImage self)"""
        return _SimpleITK.VectorOfImage_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorOfImage self) -> std::vector< slicer_itk::simple::Image >::allocator_type"""
        return _SimpleITK.VectorOfImage_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorOfImage self)"""
        return _SimpleITK.VectorOfImage_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorOfImage self, std::vector< slicer_itk::simple::Image >::iterator pos) -> std::vector< slicer_itk::simple::Image >::iterator
        erase(VectorOfImage self, std::vector< slicer_itk::simple::Image >::iterator first, std::vector< slicer_itk::simple::Image >::iterator last) -> std::vector< slicer_itk::simple::Image >::iterator
        """
        return _SimpleITK.VectorOfImage_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorOfImage self) -> VectorOfImage
        __init__(VectorOfImage self, VectorOfImage other) -> VectorOfImage
        __init__(VectorOfImage self, std::vector< slicer_itk::simple::Image >::size_type size) -> VectorOfImage
        __init__(VectorOfImage self, std::vector< slicer_itk::simple::Image >::size_type size, Image value) -> VectorOfImage
        """
        _SimpleITK.VectorOfImage_swiginit(self, _SimpleITK.new_VectorOfImage(*args))

    def push_back(self, x):
        r"""push_back(VectorOfImage self, Image x)"""
        return _SimpleITK.VectorOfImage_push_back(self, x)

    def front(self):
        r"""front(VectorOfImage self) -> Image"""
        return _SimpleITK.VectorOfImage_front(self)

    def back(self):
        r"""back(VectorOfImage self) -> Image"""
        return _SimpleITK.VectorOfImage_back(self)

    def assign(self, n, x):
        r"""assign(VectorOfImage self, std::vector< slicer_itk::simple::Image >::size_type n, Image x)"""
        return _SimpleITK.VectorOfImage_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorOfImage self, std::vector< slicer_itk::simple::Image >::size_type new_size)
        resize(VectorOfImage self, std::vector< slicer_itk::simple::Image >::size_type new_size, Image x)
        """
        return _SimpleITK.VectorOfImage_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorOfImage self, std::vector< slicer_itk::simple::Image >::iterator pos, Image x) -> std::vector< slicer_itk::simple::Image >::iterator
        insert(VectorOfImage self, std::vector< slicer_itk::simple::Image >::iterator pos, std::vector< slicer_itk::simple::Image >::size_type n, Image x)
        """
        return _SimpleITK.VectorOfImage_insert(self, *args)

    def reserve(self, n):
        r"""reserve(VectorOfImage self, std::vector< slicer_itk::simple::Image >::size_type n)"""
        return _SimpleITK.VectorOfImage_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorOfImage self) -> std::vector< slicer_itk::simple::Image >::size_type"""
        return _SimpleITK.VectorOfImage_capacity(self)
    __swig_destroy__ = _SimpleITK.delete_VectorOfImage

# Register VectorOfImage in _SimpleITK:
_SimpleITK.VectorOfImage_swigregister(VectorOfImage)
class VectorOfTransform(object):
    r"""Proxy of C++ std::vector< slicer_itk::simple::Transform > class."""

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

    def iterator(self):
        r"""iterator(VectorOfTransform self) -> SwigPyIterator"""
        return _SimpleITK.VectorOfTransform_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorOfTransform self) -> bool"""
        return _SimpleITK.VectorOfTransform___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorOfTransform self) -> bool"""
        return _SimpleITK.VectorOfTransform___bool__(self)

    def __len__(self):
        r"""__len__(VectorOfTransform self) -> std::vector< slicer_itk::simple::Transform >::size_type"""
        return _SimpleITK.VectorOfTransform___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(VectorOfTransform self, std::vector< slicer_itk::simple::Transform >::difference_type i, std::vector< slicer_itk::simple::Transform >::difference_type j) -> VectorOfTransform"""
        return _SimpleITK.VectorOfTransform___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorOfTransform self, std::vector< slicer_itk::simple::Transform >::difference_type i, std::vector< slicer_itk::simple::Transform >::difference_type j)
        __setslice__(VectorOfTransform self, std::vector< slicer_itk::simple::Transform >::difference_type i, std::vector< slicer_itk::simple::Transform >::difference_type j, VectorOfTransform v)
        """
        return _SimpleITK.VectorOfTransform___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(VectorOfTransform self, std::vector< slicer_itk::simple::Transform >::difference_type i, std::vector< slicer_itk::simple::Transform >::difference_type j)"""
        return _SimpleITK.VectorOfTransform___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorOfTransform self, std::vector< slicer_itk::simple::Transform >::difference_type i)
        __delitem__(VectorOfTransform self, SWIGPY_SLICEOBJECT * slice)
        """
        return _SimpleITK.VectorOfTransform___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorOfTransform self, SWIGPY_SLICEOBJECT * slice) -> VectorOfTransform
        __getitem__(VectorOfTransform self, std::vector< slicer_itk::simple::Transform >::difference_type i) -> Transform
        """
        return _SimpleITK.VectorOfTransform___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorOfTransform self, SWIGPY_SLICEOBJECT * slice, VectorOfTransform v)
        __setitem__(VectorOfTransform self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(VectorOfTransform self, std::vector< slicer_itk::simple::Transform >::difference_type i, Transform x)
        """
        return _SimpleITK.VectorOfTransform___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorOfTransform self) -> Transform"""
        return _SimpleITK.VectorOfTransform_pop(self)

    def append(self, x):
        r"""append(VectorOfTransform self, Transform x)"""
        return _SimpleITK.VectorOfTransform_append(self, x)

    def empty(self):
        r"""empty(VectorOfTransform self) -> bool"""
        return _SimpleITK.VectorOfTransform_empty(self)

    def size(self):
        r"""size(VectorOfTransform self) -> std::vector< slicer_itk::simple::Transform >::size_type"""
        return _SimpleITK.VectorOfTransform_size(self)

    def swap(self, v):
        r"""swap(VectorOfTransform self, VectorOfTransform v)"""
        return _SimpleITK.VectorOfTransform_swap(self, v)

    def begin(self):
        r"""begin(VectorOfTransform self) -> std::vector< slicer_itk::simple::Transform >::iterator"""
        return _SimpleITK.VectorOfTransform_begin(self)

    def end(self):
        r"""end(VectorOfTransform self) -> std::vector< slicer_itk::simple::Transform >::iterator"""
        return _SimpleITK.VectorOfTransform_end(self)

    def rbegin(self):
        r"""rbegin(VectorOfTransform self) -> std::vector< slicer_itk::simple::Transform >::reverse_iterator"""
        return _SimpleITK.VectorOfTransform_rbegin(self)

    def rend(self):
        r"""rend(VectorOfTransform self) -> std::vector< slicer_itk::simple::Transform >::reverse_iterator"""
        return _SimpleITK.VectorOfTransform_rend(self)

    def clear(self):
        r"""clear(VectorOfTransform self)"""
        return _SimpleITK.VectorOfTransform_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorOfTransform self) -> std::vector< slicer_itk::simple::Transform >::allocator_type"""
        return _SimpleITK.VectorOfTransform_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorOfTransform self)"""
        return _SimpleITK.VectorOfTransform_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorOfTransform self, std::vector< slicer_itk::simple::Transform >::iterator pos) -> std::vector< slicer_itk::simple::Transform >::iterator
        erase(VectorOfTransform self, std::vector< slicer_itk::simple::Transform >::iterator first, std::vector< slicer_itk::simple::Transform >::iterator last) -> std::vector< slicer_itk::simple::Transform >::iterator
        """
        return _SimpleITK.VectorOfTransform_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorOfTransform self) -> VectorOfTransform
        __init__(VectorOfTransform self, VectorOfTransform other) -> VectorOfTransform
        __init__(VectorOfTransform self, std::vector< slicer_itk::simple::Transform >::size_type size) -> VectorOfTransform
        __init__(VectorOfTransform self, std::vector< slicer_itk::simple::Transform >::size_type size, Transform value) -> VectorOfTransform
        """
        _SimpleITK.VectorOfTransform_swiginit(self, _SimpleITK.new_VectorOfTransform(*args))

    def push_back(self, x):
        r"""push_back(VectorOfTransform self, Transform x)"""
        return _SimpleITK.VectorOfTransform_push_back(self, x)

    def front(self):
        r"""front(VectorOfTransform self) -> Transform"""
        return _SimpleITK.VectorOfTransform_front(self)

    def back(self):
        r"""back(VectorOfTransform self) -> Transform"""
        return _SimpleITK.VectorOfTransform_back(self)

    def assign(self, n, x):
        r"""assign(VectorOfTransform self, std::vector< slicer_itk::simple::Transform >::size_type n, Transform x)"""
        return _SimpleITK.VectorOfTransform_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorOfTransform self, std::vector< slicer_itk::simple::Transform >::size_type new_size)
        resize(VectorOfTransform self, std::vector< slicer_itk::simple::Transform >::size_type new_size, Transform x)
        """
        return _SimpleITK.VectorOfTransform_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorOfTransform self, std::vector< slicer_itk::simple::Transform >::iterator pos, Transform x) -> std::vector< slicer_itk::simple::Transform >::iterator
        insert(VectorOfTransform self, std::vector< slicer_itk::simple::Transform >::iterator pos, std::vector< slicer_itk::simple::Transform >::size_type n, Transform x)
        """
        return _SimpleITK.VectorOfTransform_insert(self, *args)

    def reserve(self, n):
        r"""reserve(VectorOfTransform self, std::vector< slicer_itk::simple::Transform >::size_type n)"""
        return _SimpleITK.VectorOfTransform_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorOfTransform self) -> std::vector< slicer_itk::simple::Transform >::size_type"""
        return _SimpleITK.VectorOfTransform_capacity(self)
    __swig_destroy__ = _SimpleITK.delete_VectorOfTransform

# Register VectorOfTransform in _SimpleITK:
_SimpleITK.VectorOfTransform_swigregister(VectorOfTransform)
class VectorUIntList(object):
    r"""Proxy of C++ std::vector< std::vector< unsigned int > > class."""

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

    def iterator(self):
        r"""iterator(VectorUIntList self) -> SwigPyIterator"""
        return _SimpleITK.VectorUIntList_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorUIntList self) -> bool"""
        return _SimpleITK.VectorUIntList___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorUIntList self) -> bool"""
        return _SimpleITK.VectorUIntList___bool__(self)

    def __len__(self):
        r"""__len__(VectorUIntList self) -> std::vector< std::vector< unsigned int > >::size_type"""
        return _SimpleITK.VectorUIntList___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(VectorUIntList self, std::vector< std::vector< unsigned int > >::difference_type i, std::vector< std::vector< unsigned int > >::difference_type j) -> VectorUIntList"""
        return _SimpleITK.VectorUIntList___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorUIntList self, std::vector< std::vector< unsigned int > >::difference_type i, std::vector< std::vector< unsigned int > >::difference_type j)
        __setslice__(VectorUIntList self, std::vector< std::vector< unsigned int > >::difference_type i, std::vector< std::vector< unsigned int > >::difference_type j, VectorUIntList v)
        """
        return _SimpleITK.VectorUIntList___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(VectorUIntList self, std::vector< std::vector< unsigned int > >::difference_type i, std::vector< std::vector< unsigned int > >::difference_type j)"""
        return _SimpleITK.VectorUIntList___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorUIntList self, std::vector< std::vector< unsigned int > >::difference_type i)
        __delitem__(VectorUIntList self, SWIGPY_SLICEOBJECT * slice)
        """
        return _SimpleITK.VectorUIntList___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorUIntList self, SWIGPY_SLICEOBJECT * slice) -> VectorUIntList
        __getitem__(VectorUIntList self, std::vector< std::vector< unsigned int > >::difference_type i) -> VectorUInt32
        """
        return _SimpleITK.VectorUIntList___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorUIntList self, SWIGPY_SLICEOBJECT * slice, VectorUIntList v)
        __setitem__(VectorUIntList self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(VectorUIntList self, std::vector< std::vector< unsigned int > >::difference_type i, VectorUInt32 x)
        """
        return _SimpleITK.VectorUIntList___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorUIntList self) -> VectorUInt32"""
        return _SimpleITK.VectorUIntList_pop(self)

    def append(self, x):
        r"""append(VectorUIntList self, VectorUInt32 x)"""
        return _SimpleITK.VectorUIntList_append(self, x)

    def empty(self):
        r"""empty(VectorUIntList self) -> bool"""
        return _SimpleITK.VectorUIntList_empty(self)

    def size(self):
        r"""size(VectorUIntList self) -> std::vector< std::vector< unsigned int > >::size_type"""
        return _SimpleITK.VectorUIntList_size(self)

    def swap(self, v):
        r"""swap(VectorUIntList self, std::vector< std::vector< unsigned int,std::allocator< unsigned int > > > & v)"""
        return _SimpleITK.VectorUIntList_swap(self, v)

    def begin(self):
        r"""begin(VectorUIntList self) -> std::vector< std::vector< unsigned int > >::iterator"""
        return _SimpleITK.VectorUIntList_begin(self)

    def end(self):
        r"""end(VectorUIntList self) -> std::vector< std::vector< unsigned int > >::iterator"""
        return _SimpleITK.VectorUIntList_end(self)

    def rbegin(self):
        r"""rbegin(VectorUIntList self) -> std::vector< std::vector< unsigned int > >::reverse_iterator"""
        return _SimpleITK.VectorUIntList_rbegin(self)

    def rend(self):
        r"""rend(VectorUIntList self) -> std::vector< std::vector< unsigned int > >::reverse_iterator"""
        return _SimpleITK.VectorUIntList_rend(self)

    def clear(self):
        r"""clear(VectorUIntList self)"""
        return _SimpleITK.VectorUIntList_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorUIntList self) -> std::vector< std::vector< unsigned int > >::allocator_type"""
        return _SimpleITK.VectorUIntList_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorUIntList self)"""
        return _SimpleITK.VectorUIntList_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorUIntList self, std::vector< std::vector< unsigned int > >::iterator pos) -> std::vector< std::vector< unsigned int > >::iterator
        erase(VectorUIntList self, std::vector< std::vector< unsigned int > >::iterator first, std::vector< std::vector< unsigned int > >::iterator last) -> std::vector< std::vector< unsigned int > >::iterator
        """
        return _SimpleITK.VectorUIntList_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorUIntList self) -> VectorUIntList
        __init__(VectorUIntList self, std::vector< std::vector< unsigned int,std::allocator< unsigned int > > > const & other) -> VectorUIntList
        __init__(VectorUIntList self, std::vector< std::vector< unsigned int > >::size_type size) -> VectorUIntList
        __init__(VectorUIntList self, std::vector< std::vector< unsigned int > >::size_type size, VectorUInt32 value) -> VectorUIntList
        """
        _SimpleITK.VectorUIntList_swiginit(self, _SimpleITK.new_VectorUIntList(*args))

    def push_back(self, x):
        r"""push_back(VectorUIntList self, VectorUInt32 x)"""
        return _SimpleITK.VectorUIntList_push_back(self, x)

    def front(self):
        r"""front(VectorUIntList self) -> VectorUInt32"""
        return _SimpleITK.VectorUIntList_front(self)

    def back(self):
        r"""back(VectorUIntList self) -> VectorUInt32"""
        return _SimpleITK.VectorUIntList_back(self)

    def assign(self, n, x):
        r"""assign(VectorUIntList self, std::vector< std::vector< unsigned int > >::size_type n, VectorUInt32 x)"""
        return _SimpleITK.VectorUIntList_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorUIntList self, std::vector< std::vector< unsigned int > >::size_type new_size)
        resize(VectorUIntList self, std::vector< std::vector< unsigned int > >::size_type new_size, VectorUInt32 x)
        """
        return _SimpleITK.VectorUIntList_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorUIntList self, std::vector< std::vector< unsigned int > >::iterator pos, VectorUInt32 x) -> std::vector< std::vector< unsigned int > >::iterator
        insert(VectorUIntList self, std::vector< std::vector< unsigned int > >::iterator pos, std::vector< std::vector< unsigned int > >::size_type n, VectorUInt32 x)
        """
        return _SimpleITK.VectorUIntList_insert(self, *args)

    def reserve(self, n):
        r"""reserve(VectorUIntList self, std::vector< std::vector< unsigned int > >::size_type n)"""
        return _SimpleITK.VectorUIntList_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorUIntList self) -> std::vector< std::vector< unsigned int > >::size_type"""
        return _SimpleITK.VectorUIntList_capacity(self)
    __swig_destroy__ = _SimpleITK.delete_VectorUIntList

# Register VectorUIntList in _SimpleITK:
_SimpleITK.VectorUIntList_swigregister(VectorUIntList)
class VectorString(object):
    r"""Proxy of C++ std::vector< std::string > class."""

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

    def iterator(self):
        r"""iterator(VectorString self) -> SwigPyIterator"""
        return _SimpleITK.VectorString_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorString self) -> bool"""
        return _SimpleITK.VectorString___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorString self) -> bool"""
        return _SimpleITK.VectorString___bool__(self)

    def __len__(self):
        r"""__len__(VectorString self) -> std::vector< std::string >::size_type"""
        return _SimpleITK.VectorString___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(VectorString self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> VectorString"""
        return _SimpleITK.VectorString___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorString self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)
        __setslice__(VectorString self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, VectorString v)
        """
        return _SimpleITK.VectorString___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(VectorString self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"""
        return _SimpleITK.VectorString___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorString self, std::vector< std::string >::difference_type i)
        __delitem__(VectorString self, SWIGPY_SLICEOBJECT * slice)
        """
        return _SimpleITK.VectorString___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorString self, SWIGPY_SLICEOBJECT * slice) -> VectorString
        __getitem__(VectorString self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &
        """
        return _SimpleITK.VectorString___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorString self, SWIGPY_SLICEOBJECT * slice, VectorString v)
        __setitem__(VectorString self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(VectorString self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)
        """
        return _SimpleITK.VectorString___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorString self) -> std::vector< std::string >::value_type"""
        return _SimpleITK.VectorString_pop(self)

    def append(self, x):
        r"""append(VectorString self, std::vector< std::string >::value_type const & x)"""
        return _SimpleITK.VectorString_append(self, x)

    def empty(self):
        r"""empty(VectorString self) -> bool"""
        return _SimpleITK.VectorString_empty(self)

    def size(self):
        r"""size(VectorString self) -> std::vector< std::string >::size_type"""
        return _SimpleITK.VectorString_size(self)

    def swap(self, v):
        r"""swap(VectorString self, VectorString v)"""
        return _SimpleITK.VectorString_swap(self, v)

    def begin(self):
        r"""begin(VectorString self) -> std::vector< std::string >::iterator"""
        return _SimpleITK.VectorString_begin(self)

    def end(self):
        r"""end(VectorString self) -> std::vector< std::string >::iterator"""
        return _SimpleITK.VectorString_end(self)

    def rbegin(self):
        r"""rbegin(VectorString self) -> std::vector< std::string >::reverse_iterator"""
        return _SimpleITK.VectorString_rbegin(self)

    def rend(self):
        r"""rend(VectorString self) -> std::vector< std::string >::reverse_iterator"""
        return _SimpleITK.VectorString_rend(self)

    def clear(self):
        r"""clear(VectorString self)"""
        return _SimpleITK.VectorString_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorString self) -> std::vector< std::string >::allocator_type"""
        return _SimpleITK.VectorString_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorString self)"""
        return _SimpleITK.VectorString_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorString self, std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator
        erase(VectorString self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator
        """
        return _SimpleITK.VectorString_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorString self) -> VectorString
        __init__(VectorString self, VectorString other) -> VectorString
        __init__(VectorString self, std::vector< std::string >::size_type size) -> VectorString
        __init__(VectorString self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> VectorString
        """
        _SimpleITK.VectorString_swiginit(self, _SimpleITK.new_VectorString(*args))

    def push_back(self, x):
        r"""push_back(VectorString self, std::vector< std::string >::value_type const & x)"""
        return _SimpleITK.VectorString_push_back(self, x)

    def front(self):
        r"""front(VectorString self) -> std::vector< std::string >::value_type const &"""
        return _SimpleITK.VectorString_front(self)

    def back(self):
        r"""back(VectorString self) -> std::vector< std::string >::value_type const &"""
        return _SimpleITK.VectorString_back(self)

    def assign(self, n, x):
        r"""assign(VectorString self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)"""
        return _SimpleITK.VectorString_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorString self, std::vector< std::string >::size_type new_size)
        resize(VectorString self, std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const & x)
        """
        return _SimpleITK.VectorString_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorString self, std::vector< std::string >::iterator pos, std::vector< std::string >::value_type const & x) -> std::vector< std::string >::iterator
        insert(VectorString self, std::vector< std::string >::iterator pos, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)
        """
        return _SimpleITK.VectorString_insert(self, *args)

    def reserve(self, n):
        r"""reserve(VectorString self, std::vector< std::string >::size_type n)"""
        return _SimpleITK.VectorString_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorString self) -> std::vector< std::string >::size_type"""
        return _SimpleITK.VectorString_capacity(self)
    __swig_destroy__ = _SimpleITK.delete_VectorString

# Register VectorString in _SimpleITK:
_SimpleITK.VectorString_swigregister(VectorString)
class DoubleDoubleMap(object):
    r"""Proxy of C++ std::map< double,double > class."""

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

    def iterator(self):
        r"""iterator(DoubleDoubleMap self) -> SwigPyIterator"""
        return _SimpleITK.DoubleDoubleMap_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(DoubleDoubleMap self) -> bool"""
        return _SimpleITK.DoubleDoubleMap___nonzero__(self)

    def __bool__(self):
        r"""__bool__(DoubleDoubleMap self) -> bool"""
        return _SimpleITK.DoubleDoubleMap___bool__(self)

    def __len__(self):
        r"""__len__(DoubleDoubleMap self) -> std::map< double,double >::size_type"""
        return _SimpleITK.DoubleDoubleMap___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        r"""__getitem__(DoubleDoubleMap self, std::map< double,double >::key_type const & key) -> std::map< double,double >::mapped_type const &"""
        return _SimpleITK.DoubleDoubleMap___getitem__(self, key)

    def __delitem__(self, key):
        r"""__delitem__(DoubleDoubleMap self, std::map< double,double >::key_type const & key)"""
        return _SimpleITK.DoubleDoubleMap___delitem__(self, key)

    def has_key(self, key):
        r"""has_key(DoubleDoubleMap self, std::map< double,double >::key_type const & key) -> bool"""
        return _SimpleITK.DoubleDoubleMap_has_key(self, key)

    def keys(self):
        r"""keys(DoubleDoubleMap self) -> PyObject *"""
        return _SimpleITK.DoubleDoubleMap_keys(self)

    def values(self):
        r"""values(DoubleDoubleMap self) -> PyObject *"""
        return _SimpleITK.DoubleDoubleMap_values(self)

    def items(self):
        r"""items(DoubleDoubleMap self) -> PyObject *"""
        return _SimpleITK.DoubleDoubleMap_items(self)

    def __contains__(self, key):
        r"""__contains__(DoubleDoubleMap self, std::map< double,double >::key_type const & key) -> bool"""
        return _SimpleITK.DoubleDoubleMap___contains__(self, key)

    def key_iterator(self):
        r"""key_iterator(DoubleDoubleMap self) -> SwigPyIterator"""
        return _SimpleITK.DoubleDoubleMap_key_iterator(self)

    def value_iterator(self):
        r"""value_iterator(DoubleDoubleMap self) -> SwigPyIterator"""
        return _SimpleITK.DoubleDoubleMap_value_iterator(self)

    def __setitem__(self, *args):
        r"""
        __setitem__(DoubleDoubleMap self, std::map< double,double >::key_type const & key)
        __setitem__(DoubleDoubleMap self, std::map< double,double >::key_type const & key, std::map< double,double >::mapped_type const & x)
        """
        return _SimpleITK.DoubleDoubleMap___setitem__(self, *args)

    def asdict(self):
        r"""asdict(DoubleDoubleMap self) -> PyObject *"""
        return _SimpleITK.DoubleDoubleMap_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(DoubleDoubleMap self, std::less< double > const & other) -> DoubleDoubleMap
        __init__(DoubleDoubleMap self) -> DoubleDoubleMap
        __init__(DoubleDoubleMap self, DoubleDoubleMap other) -> DoubleDoubleMap
        """
        _SimpleITK.DoubleDoubleMap_swiginit(self, _SimpleITK.new_DoubleDoubleMap(*args))

    def empty(self):
        r"""empty(DoubleDoubleMap self) -> bool"""
        return _SimpleITK.DoubleDoubleMap_empty(self)

    def size(self):
        r"""size(DoubleDoubleMap self) -> std::map< double,double >::size_type"""
        return _SimpleITK.DoubleDoubleMap_size(self)

    def swap(self, v):
        r"""swap(DoubleDoubleMap self, DoubleDoubleMap v)"""
        return _SimpleITK.DoubleDoubleMap_swap(self, v)

    def begin(self):
        r"""begin(DoubleDoubleMap self) -> std::map< double,double >::iterator"""
        return _SimpleITK.DoubleDoubleMap_begin(self)

    def end(self):
        r"""end(DoubleDoubleMap self) -> std::map< double,double >::iterator"""
        return _SimpleITK.DoubleDoubleMap_end(self)

    def rbegin(self):
        r"""rbegin(DoubleDoubleMap self) -> std::map< double,double >::reverse_iterator"""
        return _SimpleITK.DoubleDoubleMap_rbegin(self)

    def rend(self):
        r"""rend(DoubleDoubleMap self) -> std::map< double,double >::reverse_iterator"""
        return _SimpleITK.DoubleDoubleMap_rend(self)

    def clear(self):
        r"""clear(DoubleDoubleMap self)"""
        return _SimpleITK.DoubleDoubleMap_clear(self)

    def get_allocator(self):
        r"""get_allocator(DoubleDoubleMap self) -> std::map< double,double >::allocator_type"""
        return _SimpleITK.DoubleDoubleMap_get_allocator(self)

    def count(self, x):
        r"""count(DoubleDoubleMap self, std::map< double,double >::key_type const & x) -> std::map< double,double >::size_type"""
        return _SimpleITK.DoubleDoubleMap_count(self, x)

    def erase(self, *args):
        r"""
        erase(DoubleDoubleMap self, std::map< double,double >::key_type const & x) -> std::map< double,double >::size_type
        erase(DoubleDoubleMap self, std::map< double,double >::iterator position)
        erase(DoubleDoubleMap self, std::map< double,double >::iterator first, std::map< double,double >::iterator last)
        """
        return _SimpleITK.DoubleDoubleMap_erase(self, *args)

    def find(self, x):
        r"""find(DoubleDoubleMap self, std::map< double,double >::key_type const & x) -> std::map< double,double >::iterator"""
        return _SimpleITK.DoubleDoubleMap_find(self, x)

    def lower_bound(self, x):
        r"""lower_bound(DoubleDoubleMap self, std::map< double,double >::key_type const & x) -> std::map< double,double >::iterator"""
        return _SimpleITK.DoubleDoubleMap_lower_bound(self, x)

    def upper_bound(self, x):
        r"""upper_bound(DoubleDoubleMap self, std::map< double,double >::key_type const & x) -> std::map< double,double >::iterator"""
        return _SimpleITK.DoubleDoubleMap_upper_bound(self, x)
    __swig_destroy__ = _SimpleITK.delete_DoubleDoubleMap

# Register DoubleDoubleMap in _SimpleITK:
_SimpleITK.DoubleDoubleMap_swigregister(DoubleDoubleMap)

import operator
import sys
from collections import namedtuple

SITK_MAX_DIMENSION = _SimpleITK.SITK_MAX_DIMENSION

SITK_ITK_VERSION_MAJOR = _SimpleITK.SITK_ITK_VERSION_MAJOR

SITK_ITK_VERSION_MINOR = _SimpleITK.SITK_ITK_VERSION_MINOR

SITK_ITK_VERSION_PATCH = _SimpleITK.SITK_ITK_VERSION_PATCH

class Version(object):
    r"""Proxy of C++ slicer_itk::simple::Version class."""

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

    @staticmethod
    def MajorVersion():
        r"""MajorVersion() -> unsigned int"""
        return _SimpleITK.Version_MajorVersion()

    @staticmethod
    def MinorVersion():
        r"""MinorVersion() -> unsigned int"""
        return _SimpleITK.Version_MinorVersion()

    @staticmethod
    def PatchVersion():
        r"""PatchVersion() -> unsigned int"""
        return _SimpleITK.Version_PatchVersion()

    @staticmethod
    def TweakVersion():
        r"""TweakVersion() -> unsigned int"""
        return _SimpleITK.Version_TweakVersion()

    @staticmethod
    def VersionString():
        r"""VersionString() -> std::string const &"""
        return _SimpleITK.Version_VersionString()

    @staticmethod
    def BuildDate():
        r"""BuildDate() -> std::string const &"""
        return _SimpleITK.Version_BuildDate()

    @staticmethod
    def ITKMajorVersion():
        r"""ITKMajorVersion() -> unsigned int"""
        return _SimpleITK.Version_ITKMajorVersion()

    @staticmethod
    def ITKMinorVersion():
        r"""ITKMinorVersion() -> unsigned int"""
        return _SimpleITK.Version_ITKMinorVersion()

    @staticmethod
    def ITKPatchVersion():
        r"""ITKPatchVersion() -> unsigned int"""
        return _SimpleITK.Version_ITKPatchVersion()

    @staticmethod
    def ITKVersionString():
        r"""ITKVersionString() -> std::string const &"""
        return _SimpleITK.Version_ITKVersionString()

    @staticmethod
    def ITKModulesEnabled():
        r"""ITKModulesEnabled() -> VectorString"""
        return _SimpleITK.Version_ITKModulesEnabled()

    @staticmethod
    def ExtendedVersionString():
        r"""ExtendedVersionString() -> std::string const &"""
        return _SimpleITK.Version_ExtendedVersionString()

    def __str__(self):
        r"""__str__(Version self) -> std::string"""
        return _SimpleITK.Version___str__(self)

    def __init__(self):
        r"""__init__(Version self) -> Version"""
        _SimpleITK.Version_swiginit(self, _SimpleITK.new_Version())
    __swig_destroy__ = _SimpleITK.delete_Version

# Register Version in _SimpleITK:
_SimpleITK.Version_swigregister(Version)
_GetMemoryViewFromImage = _SimpleITK._GetMemoryViewFromImage
_SetImageFromArray = _SimpleITK._SetImageFromArray

def Version_MajorVersion():
    r"""Version_MajorVersion() -> unsigned int"""
    return _SimpleITK.Version_MajorVersion()

def Version_MinorVersion():
    r"""Version_MinorVersion() -> unsigned int"""
    return _SimpleITK.Version_MinorVersion()

def Version_PatchVersion():
    r"""Version_PatchVersion() -> unsigned int"""
    return _SimpleITK.Version_PatchVersion()

def Version_TweakVersion():
    r"""Version_TweakVersion() -> unsigned int"""
    return _SimpleITK.Version_TweakVersion()

def Version_VersionString():
    r"""Version_VersionString() -> std::string const &"""
    return _SimpleITK.Version_VersionString()

def Version_BuildDate():
    r"""Version_BuildDate() -> std::string const &"""
    return _SimpleITK.Version_BuildDate()

def Version_ITKMajorVersion():
    r"""Version_ITKMajorVersion() -> unsigned int"""
    return _SimpleITK.Version_ITKMajorVersion()

def Version_ITKMinorVersion():
    r"""Version_ITKMinorVersion() -> unsigned int"""
    return _SimpleITK.Version_ITKMinorVersion()

def Version_ITKPatchVersion():
    r"""Version_ITKPatchVersion() -> unsigned int"""
    return _SimpleITK.Version_ITKPatchVersion()

def Version_ITKVersionString():
    r"""Version_ITKVersionString() -> std::string const &"""
    return _SimpleITK.Version_ITKVersionString()

def Version_ITKModulesEnabled():
    r"""Version_ITKModulesEnabled() -> VectorString"""
    return _SimpleITK.Version_ITKModulesEnabled()

def Version_ExtendedVersionString():
    r"""Version_ExtendedVersionString() -> std::string const &"""
    return _SimpleITK.Version_ExtendedVersionString()

sitkUnknown = _SimpleITK.sitkUnknown

sitkUInt8 = _SimpleITK.sitkUInt8

sitkInt8 = _SimpleITK.sitkInt8

sitkUInt16 = _SimpleITK.sitkUInt16

sitkInt16 = _SimpleITK.sitkInt16

sitkUInt32 = _SimpleITK.sitkUInt32

sitkInt32 = _SimpleITK.sitkInt32

sitkUInt64 = _SimpleITK.sitkUInt64

sitkInt64 = _SimpleITK.sitkInt64

sitkFloat32 = _SimpleITK.sitkFloat32

sitkFloat64 = _SimpleITK.sitkFloat64

sitkComplexFloat32 = _SimpleITK.sitkComplexFloat32

sitkComplexFloat64 = _SimpleITK.sitkComplexFloat64

sitkVectorUInt8 = _SimpleITK.sitkVectorUInt8

sitkVectorInt8 = _SimpleITK.sitkVectorInt8

sitkVectorUInt16 = _SimpleITK.sitkVectorUInt16

sitkVectorInt16 = _SimpleITK.sitkVectorInt16

sitkVectorUInt32 = _SimpleITK.sitkVectorUInt32

sitkVectorInt32 = _SimpleITK.sitkVectorInt32

sitkVectorUInt64 = _SimpleITK.sitkVectorUInt64

sitkVectorInt64 = _SimpleITK.sitkVectorInt64

sitkVectorFloat32 = _SimpleITK.sitkVectorFloat32

sitkVectorFloat64 = _SimpleITK.sitkVectorFloat64

sitkLabelUInt8 = _SimpleITK.sitkLabelUInt8

sitkLabelUInt16 = _SimpleITK.sitkLabelUInt16

sitkLabelUInt32 = _SimpleITK.sitkLabelUInt32

sitkLabelUInt64 = _SimpleITK.sitkLabelUInt64


def GetPixelIDValueAsString(type):
    r"""GetPixelIDValueAsString(slicer_itk::simple::PixelIDValueEnum type) -> std::string const"""
    return _SimpleITK.GetPixelIDValueAsString(type)

def GetPixelIDValueFromString(enumString):
    r"""GetPixelIDValueFromString(std::string const & enumString) -> slicer_itk::simple::PixelIDValueType"""
    return _SimpleITK.GetPixelIDValueFromString(enumString)
sitkNearestNeighbor = _SimpleITK.sitkNearestNeighbor

sitkLinear = _SimpleITK.sitkLinear

sitkBSpline1 = _SimpleITK.sitkBSpline1

sitkBSpline2 = _SimpleITK.sitkBSpline2

sitkBSpline = _SimpleITK.sitkBSpline

sitkBSpline3 = _SimpleITK.sitkBSpline3

sitkBSpline4 = _SimpleITK.sitkBSpline4

sitkBSpline5 = _SimpleITK.sitkBSpline5

sitkGaussian = _SimpleITK.sitkGaussian

sitkLabelGaussian = _SimpleITK.sitkLabelGaussian

sitkLabelLinear = _SimpleITK.sitkLabelLinear

sitkHammingWindowedSinc = _SimpleITK.sitkHammingWindowedSinc

sitkCosineWindowedSinc = _SimpleITK.sitkCosineWindowedSinc

sitkWelchWindowedSinc = _SimpleITK.sitkWelchWindowedSinc

sitkLanczosWindowedSinc = _SimpleITK.sitkLanczosWindowedSinc

sitkBlackmanWindowedSinc = _SimpleITK.sitkBlackmanWindowedSinc

sitkBSplineResampler = _SimpleITK.sitkBSplineResampler

sitkBSplineResamplerOrder3 = _SimpleITK.sitkBSplineResamplerOrder3

sitkBSplineResamplerOrder1 = _SimpleITK.sitkBSplineResamplerOrder1

sitkBSplineResamplerOrder2 = _SimpleITK.sitkBSplineResamplerOrder2

sitkBSplineResamplerOrder4 = _SimpleITK.sitkBSplineResamplerOrder4

sitkBSplineResamplerOrder5 = _SimpleITK.sitkBSplineResamplerOrder5

class Image(object):
    r"""Proxy of C++ slicer_itk::simple::Image class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_Image

    def __init__(self, *args):
        r"""
        __init__(Image self) -> Image
        __init__(Image self, Image img) -> Image
        __init__(Image self, unsigned int width, unsigned int height, slicer_itk::simple::PixelIDValueEnum valueEnum) -> Image
        __init__(Image self, unsigned int width, unsigned int height, unsigned int depth, slicer_itk::simple::PixelIDValueEnum valueEnum) -> Image
        __init__(Image self, VectorUInt32 size, slicer_itk::simple::PixelIDValueEnum valueEnum, unsigned int numberOfComponents=0) -> Image
        """
        _SimpleITK.Image_swiginit(self, _SimpleITK.new_Image(*args))

    def GetITKBase(self, *args):
        r"""
        GetITKBase(Image self) -> slicer_itk::DataObject
        GetITKBase(Image self) -> slicer_itk::DataObject const *
        """
        return _SimpleITK.Image_GetITKBase(self, *args)

    def GetPixelID(self):
        r"""GetPixelID(Image self) -> slicer_itk::simple::PixelIDValueEnum"""
        return _SimpleITK.Image_GetPixelID(self)

    def GetPixelIDValue(self):
        r"""GetPixelIDValue(Image self) -> slicer_itk::simple::PixelIDValueType"""
        return _SimpleITK.Image_GetPixelIDValue(self)

    def GetPixelIDTypeAsString(self):
        r"""GetPixelIDTypeAsString(Image self) -> std::string"""
        return _SimpleITK.Image_GetPixelIDTypeAsString(self)

    def GetDimension(self):
        r"""GetDimension(Image self) -> unsigned int"""
        return _SimpleITK.Image_GetDimension(self)

    def GetNumberOfComponentsPerPixel(self):
        r"""GetNumberOfComponentsPerPixel(Image self) -> unsigned int"""
        return _SimpleITK.Image_GetNumberOfComponentsPerPixel(self)

    def GetNumberOfPixels(self):
        r"""GetNumberOfPixels(Image self) -> uint64_t"""
        return _SimpleITK.Image_GetNumberOfPixels(self)

    def GetSizeOfPixelComponent(self):
        r"""GetSizeOfPixelComponent(Image self) -> unsigned int"""
        return _SimpleITK.Image_GetSizeOfPixelComponent(self)

    def GetOrigin(self):
        r"""GetOrigin(Image self) -> VectorDouble"""
        return _SimpleITK.Image_GetOrigin(self)

    def SetOrigin(self, origin):
        r"""SetOrigin(Image self, VectorDouble origin)"""
        return _SimpleITK.Image_SetOrigin(self, origin)

    def GetSpacing(self):
        r"""GetSpacing(Image self) -> VectorDouble"""
        return _SimpleITK.Image_GetSpacing(self)

    def SetSpacing(self, spacing):
        r"""SetSpacing(Image self, VectorDouble spacing)"""
        return _SimpleITK.Image_SetSpacing(self, spacing)

    def GetDirection(self):
        r"""GetDirection(Image self) -> VectorDouble"""
        return _SimpleITK.Image_GetDirection(self)

    def SetDirection(self, direction):
        r"""SetDirection(Image self, VectorDouble direction)"""
        return _SimpleITK.Image_SetDirection(self, direction)

    def TransformIndexToPhysicalPoint(self, index):
        r"""TransformIndexToPhysicalPoint(Image self, VectorInt64 index) -> VectorDouble"""
        return _SimpleITK.Image_TransformIndexToPhysicalPoint(self, index)

    def TransformPhysicalPointToIndex(self, point):
        r"""TransformPhysicalPointToIndex(Image self, VectorDouble point) -> VectorInt64"""
        return _SimpleITK.Image_TransformPhysicalPointToIndex(self, point)

    def TransformPhysicalPointToContinuousIndex(self, point):
        r"""TransformPhysicalPointToContinuousIndex(Image self, VectorDouble point) -> VectorDouble"""
        return _SimpleITK.Image_TransformPhysicalPointToContinuousIndex(self, point)

    def TransformContinuousIndexToPhysicalPoint(self, index):
        r"""TransformContinuousIndexToPhysicalPoint(Image self, VectorDouble index) -> VectorDouble"""
        return _SimpleITK.Image_TransformContinuousIndexToPhysicalPoint(self, index)

    def __EvaluateAtContinuousIndex__(self, *args, **kwargs):
        r"""__EvaluateAtContinuousIndex__(Image self, VectorDouble index, slicer_itk::simple::InterpolatorEnum interp=sitkLinear) -> VectorDouble"""
        return _SimpleITK.Image___EvaluateAtContinuousIndex__(self, *args, **kwargs)

    def __EvaluateAtPhysicalPoint__(self, *args, **kwargs):
        r"""__EvaluateAtPhysicalPoint__(Image self, VectorDouble point, slicer_itk::simple::InterpolatorEnum interp=sitkLinear) -> VectorDouble"""
        return _SimpleITK.Image___EvaluateAtPhysicalPoint__(self, *args, **kwargs)

    def IsCongruentImageGeometry(self, otherImage, coordinateTolerance, directionTolerance):
        r"""IsCongruentImageGeometry(Image self, Image otherImage, double coordinateTolerance, double directionTolerance) -> bool"""
        return _SimpleITK.Image_IsCongruentImageGeometry(self, otherImage, coordinateTolerance, directionTolerance)

    def IsSameImageGeometryAs(self, *args, **kwargs):
        r"""IsSameImageGeometryAs(Image self, Image otherImage, double arg3=DefaultImageCoordinateTolerance, double arg4=DefaultImageDirectionTolerance) -> bool"""
        return _SimpleITK.Image_IsSameImageGeometryAs(self, *args, **kwargs)

    def GetSize(self):
        r"""GetSize(Image self) -> VectorUInt32"""
        return _SimpleITK.Image_GetSize(self)

    def GetWidth(self):
        r"""GetWidth(Image self) -> unsigned int"""
        return _SimpleITK.Image_GetWidth(self)

    def GetHeight(self):
        r"""GetHeight(Image self) -> unsigned int"""
        return _SimpleITK.Image_GetHeight(self)

    def GetDepth(self):
        r"""GetDepth(Image self) -> unsigned int"""
        return _SimpleITK.Image_GetDepth(self)

    def CopyInformation(self, srcImage):
        r"""CopyInformation(Image self, Image srcImage)"""
        return _SimpleITK.Image_CopyInformation(self, srcImage)

    def GetMetaDataKeys(self):
        r"""GetMetaDataKeys(Image self) -> VectorString"""
        return _SimpleITK.Image_GetMetaDataKeys(self)

    def HasMetaDataKey(self, key):
        r"""HasMetaDataKey(Image self, std::string const & key) -> bool"""
        return _SimpleITK.Image_HasMetaDataKey(self, key)

    def GetMetaData(self, key):
        r"""GetMetaData(Image self, std::string const & key) -> std::string"""
        return _SimpleITK.Image_GetMetaData(self, key)

    def SetMetaData(self, key, value):
        r"""SetMetaData(Image self, std::string const & key, std::string const & value)"""
        return _SimpleITK.Image_SetMetaData(self, key, value)

    def EraseMetaData(self, key):
        r"""EraseMetaData(Image self, std::string const & key) -> bool"""
        return _SimpleITK.Image_EraseMetaData(self, key)

    def __str__(self):
        r"""__str__(Image self) -> std::string"""
        return _SimpleITK.Image___str__(self)

    def ToVectorImage(self, inPlace=True):
        r"""ToVectorImage(Image self, bool inPlace=True) -> Image"""
        return _SimpleITK.Image_ToVectorImage(self, inPlace)

    def ToScalarImage(self, inPlace=True):
        r"""ToScalarImage(Image self, bool inPlace=True) -> Image"""
        return _SimpleITK.Image_ToScalarImage(self, inPlace)

    def __GetPixelAsInt8__(self, idx):
        r"""__GetPixelAsInt8__(Image self, VectorUInt32 idx) -> int8_t"""
        return _SimpleITK.Image___GetPixelAsInt8__(self, idx)

    def __GetPixelAsUInt8__(self, idx):
        r"""__GetPixelAsUInt8__(Image self, VectorUInt32 idx) -> uint8_t"""
        return _SimpleITK.Image___GetPixelAsUInt8__(self, idx)

    def __GetPixelAsInt16__(self, idx):
        r"""__GetPixelAsInt16__(Image self, VectorUInt32 idx) -> int16_t"""
        return _SimpleITK.Image___GetPixelAsInt16__(self, idx)

    def __GetPixelAsUInt16__(self, idx):
        r"""__GetPixelAsUInt16__(Image self, VectorUInt32 idx) -> uint16_t"""
        return _SimpleITK.Image___GetPixelAsUInt16__(self, idx)

    def __GetPixelAsInt32__(self, idx):
        r"""__GetPixelAsInt32__(Image self, VectorUInt32 idx) -> int32_t"""
        return _SimpleITK.Image___GetPixelAsInt32__(self, idx)

    def __GetPixelAsUInt32__(self, idx):
        r"""__GetPixelAsUInt32__(Image self, VectorUInt32 idx) -> uint32_t"""
        return _SimpleITK.Image___GetPixelAsUInt32__(self, idx)

    def __GetPixelAsInt64__(self, idx):
        r"""__GetPixelAsInt64__(Image self, VectorUInt32 idx) -> int64_t"""
        return _SimpleITK.Image___GetPixelAsInt64__(self, idx)

    def __GetPixelAsUInt64__(self, idx):
        r"""__GetPixelAsUInt64__(Image self, VectorUInt32 idx) -> uint64_t"""
        return _SimpleITK.Image___GetPixelAsUInt64__(self, idx)

    def __GetPixelAsFloat__(self, idx):
        r"""__GetPixelAsFloat__(Image self, VectorUInt32 idx) -> float"""
        return _SimpleITK.Image___GetPixelAsFloat__(self, idx)

    def __GetPixelAsDouble__(self, idx):
        r"""__GetPixelAsDouble__(Image self, VectorUInt32 idx) -> double"""
        return _SimpleITK.Image___GetPixelAsDouble__(self, idx)

    def __GetPixelAsVectorInt8__(self, idx):
        r"""__GetPixelAsVectorInt8__(Image self, VectorUInt32 idx) -> VectorInt8"""
        return _SimpleITK.Image___GetPixelAsVectorInt8__(self, idx)

    def __GetPixelAsVectorUInt8__(self, idx):
        r"""__GetPixelAsVectorUInt8__(Image self, VectorUInt32 idx) -> VectorUInt8"""
        return _SimpleITK.Image___GetPixelAsVectorUInt8__(self, idx)

    def __GetPixelAsVectorInt16__(self, idx):
        r"""__GetPixelAsVectorInt16__(Image self, VectorUInt32 idx) -> VectorInt16"""
        return _SimpleITK.Image___GetPixelAsVectorInt16__(self, idx)

    def __GetPixelAsVectorUInt16__(self, idx):
        r"""__GetPixelAsVectorUInt16__(Image self, VectorUInt32 idx) -> VectorUInt16"""
        return _SimpleITK.Image___GetPixelAsVectorUInt16__(self, idx)

    def __GetPixelAsVectorInt32__(self, idx):
        r"""__GetPixelAsVectorInt32__(Image self, VectorUInt32 idx) -> VectorInt32"""
        return _SimpleITK.Image___GetPixelAsVectorInt32__(self, idx)

    def __GetPixelAsVectorUInt32__(self, idx):
        r"""__GetPixelAsVectorUInt32__(Image self, VectorUInt32 idx) -> VectorUInt32"""
        return _SimpleITK.Image___GetPixelAsVectorUInt32__(self, idx)

    def __GetPixelAsVectorInt64__(self, idx):
        r"""__GetPixelAsVectorInt64__(Image self, VectorUInt32 idx) -> VectorInt64"""
        return _SimpleITK.Image___GetPixelAsVectorInt64__(self, idx)

    def __GetPixelAsVectorUInt64__(self, idx):
        r"""__GetPixelAsVectorUInt64__(Image self, VectorUInt32 idx) -> VectorUInt64"""
        return _SimpleITK.Image___GetPixelAsVectorUInt64__(self, idx)

    def __GetPixelAsVectorFloat32__(self, idx):
        r"""__GetPixelAsVectorFloat32__(Image self, VectorUInt32 idx) -> VectorFloat"""
        return _SimpleITK.Image___GetPixelAsVectorFloat32__(self, idx)

    def __GetPixelAsVectorFloat64__(self, idx):
        r"""__GetPixelAsVectorFloat64__(Image self, VectorUInt32 idx) -> VectorDouble"""
        return _SimpleITK.Image___GetPixelAsVectorFloat64__(self, idx)

    def __GetPixelAsComplexFloat32__(self, idx):
        r"""__GetPixelAsComplexFloat32__(Image self, VectorUInt32 idx) -> std::complex< float >"""
        return _SimpleITK.Image___GetPixelAsComplexFloat32__(self, idx)

    def __GetPixelAsComplexFloat64__(self, idx):
        r"""__GetPixelAsComplexFloat64__(Image self, VectorUInt32 idx) -> std::complex< double >"""
        return _SimpleITK.Image___GetPixelAsComplexFloat64__(self, idx)

    def __SetPixelAsInt8__(self, idx, v):
        r"""__SetPixelAsInt8__(Image self, VectorUInt32 idx, int8_t v)"""
        return _SimpleITK.Image___SetPixelAsInt8__(self, idx, v)

    def __SetPixelAsUInt8__(self, idx, v):
        r"""__SetPixelAsUInt8__(Image self, VectorUInt32 idx, uint8_t v)"""
        return _SimpleITK.Image___SetPixelAsUInt8__(self, idx, v)

    def __SetPixelAsInt16__(self, idx, v):
        r"""__SetPixelAsInt16__(Image self, VectorUInt32 idx, int16_t v)"""
        return _SimpleITK.Image___SetPixelAsInt16__(self, idx, v)

    def __SetPixelAsUInt16__(self, idx, v):
        r"""__SetPixelAsUInt16__(Image self, VectorUInt32 idx, uint16_t v)"""
        return _SimpleITK.Image___SetPixelAsUInt16__(self, idx, v)

    def __SetPixelAsInt32__(self, idx, v):
        r"""__SetPixelAsInt32__(Image self, VectorUInt32 idx, int32_t v)"""
        return _SimpleITK.Image___SetPixelAsInt32__(self, idx, v)

    def __SetPixelAsUInt32__(self, idx, v):
        r"""__SetPixelAsUInt32__(Image self, VectorUInt32 idx, uint32_t v)"""
        return _SimpleITK.Image___SetPixelAsUInt32__(self, idx, v)

    def __SetPixelAsInt64__(self, idx, v):
        r"""__SetPixelAsInt64__(Image self, VectorUInt32 idx, int64_t v)"""
        return _SimpleITK.Image___SetPixelAsInt64__(self, idx, v)

    def __SetPixelAsUInt64__(self, idx, v):
        r"""__SetPixelAsUInt64__(Image self, VectorUInt32 idx, uint64_t v)"""
        return _SimpleITK.Image___SetPixelAsUInt64__(self, idx, v)

    def __SetPixelAsFloat__(self, idx, v):
        r"""__SetPixelAsFloat__(Image self, VectorUInt32 idx, float v)"""
        return _SimpleITK.Image___SetPixelAsFloat__(self, idx, v)

    def __SetPixelAsDouble__(self, idx, v):
        r"""__SetPixelAsDouble__(Image self, VectorUInt32 idx, double v)"""
        return _SimpleITK.Image___SetPixelAsDouble__(self, idx, v)

    def __SetPixelAsVectorInt8__(self, idx, v):
        r"""__SetPixelAsVectorInt8__(Image self, VectorUInt32 idx, VectorInt8 v)"""
        return _SimpleITK.Image___SetPixelAsVectorInt8__(self, idx, v)

    def __SetPixelAsVectorUInt8__(self, idx, v):
        r"""__SetPixelAsVectorUInt8__(Image self, VectorUInt32 idx, VectorUInt8 v)"""
        return _SimpleITK.Image___SetPixelAsVectorUInt8__(self, idx, v)

    def __SetPixelAsVectorInt16__(self, idx, v):
        r"""__SetPixelAsVectorInt16__(Image self, VectorUInt32 idx, VectorInt16 v)"""
        return _SimpleITK.Image___SetPixelAsVectorInt16__(self, idx, v)

    def __SetPixelAsVectorUInt16__(self, idx, v):
        r"""__SetPixelAsVectorUInt16__(Image self, VectorUInt32 idx, VectorUInt16 v)"""
        return _SimpleITK.Image___SetPixelAsVectorUInt16__(self, idx, v)

    def __SetPixelAsVectorInt32__(self, idx, v):
        r"""__SetPixelAsVectorInt32__(Image self, VectorUInt32 idx, VectorInt32 v)"""
        return _SimpleITK.Image___SetPixelAsVectorInt32__(self, idx, v)

    def __SetPixelAsVectorUInt32__(self, idx, v):
        r"""__SetPixelAsVectorUInt32__(Image self, VectorUInt32 idx, VectorUInt32 v)"""
        return _SimpleITK.Image___SetPixelAsVectorUInt32__(self, idx, v)

    def __SetPixelAsVectorInt64__(self, idx, v):
        r"""__SetPixelAsVectorInt64__(Image self, VectorUInt32 idx, VectorInt64 v)"""
        return _SimpleITK.Image___SetPixelAsVectorInt64__(self, idx, v)

    def __SetPixelAsVectorUInt64__(self, idx, v):
        r"""__SetPixelAsVectorUInt64__(Image self, VectorUInt32 idx, VectorUInt64 v)"""
        return _SimpleITK.Image___SetPixelAsVectorUInt64__(self, idx, v)

    def __SetPixelAsVectorFloat32__(self, idx, v):
        r"""__SetPixelAsVectorFloat32__(Image self, VectorUInt32 idx, VectorFloat v)"""
        return _SimpleITK.Image___SetPixelAsVectorFloat32__(self, idx, v)

    def __SetPixelAsVectorFloat64__(self, idx, v):
        r"""__SetPixelAsVectorFloat64__(Image self, VectorUInt32 idx, VectorDouble v)"""
        return _SimpleITK.Image___SetPixelAsVectorFloat64__(self, idx, v)

    def __SetPixelAsComplexFloat32__(self, idx, v):
        r"""__SetPixelAsComplexFloat32__(Image self, VectorUInt32 idx, std::complex< float > const v)"""
        return _SimpleITK.Image___SetPixelAsComplexFloat32__(self, idx, v)

    def SetPixelAsComplexFloat64(self, idx, v):
        r"""SetPixelAsComplexFloat64(Image self, VectorUInt32 idx, std::complex< double > const v)"""
        return _SimpleITK.Image_SetPixelAsComplexFloat64(self, idx, v)

    def MakeUnique(self):
        r"""MakeUnique(Image self)"""
        return _SimpleITK.Image_MakeUnique(self)

    def IsUnique(self):
        r"""IsUnique(Image self) -> bool"""
        return _SimpleITK.Image_IsUnique(self)
    DefaultImageCoordinateTolerance = _SimpleITK.Image_DefaultImageCoordinateTolerance
    
    DefaultImageDirectionTolerance = _SimpleITK.Image_DefaultImageDirectionTolerance
    

    def __iadd__(self, *args):
        r"""
        __iadd__(Image self, Image i) -> Image
        __iadd__(Image self, double c) -> Image
        """
        return _SimpleITK.Image___iadd__(self, *args)

    def __isub__(self, *args):
        r"""
        __isub__(Image self, Image i) -> Image
        __isub__(Image self, double c) -> Image
        """
        return _SimpleITK.Image___isub__(self, *args)

    def __imul__(self, *args):
        r"""
        __imul__(Image self, Image i) -> Image
        __imul__(Image self, double c) -> Image
        """
        return _SimpleITK.Image___imul__(self, *args)

    def __imod__(self, *args):
        r"""
        __imod__(Image self, Image i) -> Image
        __imod__(Image self, int c) -> Image
        """
        return _SimpleITK.Image___imod__(self, *args)

    def __ifloordiv__(self, *args):
        r"""
        __ifloordiv__(Image self, Image i) -> Image
        __ifloordiv__(Image self, double c) -> Image
        """
        return _SimpleITK.Image___ifloordiv__(self, *args)

    def __itruediv__(self, *args):
        r"""
        __itruediv__(Image self, Image i) -> Image
        __itruediv__(Image self, double c) -> Image
        """
        return _SimpleITK.Image___itruediv__(self, *args)

    def __ipow__(self, *args):
        r"""
        __ipow__(Image self, Image i) -> Image
        __ipow__(Image self, double c) -> Image
        """
        return _SimpleITK.Image___ipow__(self, *args)

    def __ior__(self, *args):
        r"""
        __ior__(Image self, Image i) -> Image
        __ior__(Image self, int c) -> Image
        """
        return _SimpleITK.Image___ior__(self, *args)

    def __ixor__(self, *args):
        r"""
        __ixor__(Image self, Image i) -> Image
        __ixor__(Image self, int c) -> Image
        """
        return _SimpleITK.Image___ixor__(self, *args)

    def __iand__(self, *args):
        r"""
        __iand__(Image self, Image i) -> Image
        __iand__(Image self, int c) -> Image
        """
        return _SimpleITK.Image___iand__(self, *args)

    def __ipaste(self, *args):
        r"""
        __ipaste(Image self, Image sourceImage, VectorUInt32 sourceSize, VectorInt32 sourceIndex, VectorInt32 destinationIndex, VectorBool destinationSkipAxes) -> Image
        __ipaste(Image self, double constant, VectorUInt32 sourceSize, VectorInt32 sourceIndex, VectorInt32 destinationIndex, VectorBool destinationSkipAxes) -> Image
        """
        return _SimpleITK.Image___ipaste(self, *args)

    def __imasked_assign(self, *args):
        r"""
        __imasked_assign(Image self, Image mask, Image assign) -> Image
        __imasked_assign(Image self, Image mask, double constant) -> Image
        """
        return _SimpleITK.Image___imasked_assign(self, *args)


    def __copy__(self):
      """Create a SimpleITK shallow copy, where the internal image share is shared with copy on write implementation."""
      return Image(self)

    def __deepcopy__(self, memo):
      """Create a new copy of the data and image class."""
      dc = Image(self)
      dc.MakeUnique()
      return dc

    def __setstate__(self, args):
      if args[0] != 0:
        raise ValueError("Unable to handle SimpleITK.Image pickle version {0}".args[0])

      state = namedtuple('state_tuple_0', "version buffer origin spacing direction metadata")(*args)

      _SetImageFromArray(state.buffer, self)
      self.SetOrigin(state.origin)
      self.SetSpacing(state.spacing)
      self.SetDirection(state.direction)
      for k,v in state.metadata.items():
        self.SetMetaData(k,v)

    def __reduce_ex__(self, protocol ):
      version = 0
      size = tuple(self.GetSize())
      t = int(self.GetPixelIDValue())
      ncomponents = int(self.GetNumberOfComponentsPerPixel())

      mv = _GetMemoryViewFromImage(self)
      origin = tuple(self.GetOrigin())
      spacing = tuple(self.GetSpacing())
      direction = tuple(self.GetDirection())
      metadata = {k:self.GetMetaData(k) for k in self.GetMetaDataKeys()}

      if protocol >= 5:
        import sys
        if sys.hexversion >= 0x03080000:
          import pickle
        elif sys.hexversion >= 0x03060000:
          try:
            import pickle5 as pickle
          except ImportError:
            raise ImportError("Pickle protocol 5 requires the pickle5 module for Python 3.6, 3.7")
        P = (version, pickle.PickleBuffer(mv), origin, spacing, direction, metadata)
      else:
        P = (version, mv.tobytes(), origin, spacing, direction, metadata)

      return self.__class__, (size, t, ncomponents), P



    # mathematical operators

    def __add__( self, other ):
        if isinstance( other, Image ):
           return Add( self, other )
        try:
           return Add( self, float(other)  )
        except ValueError:
           return NotImplemented
    def __sub__( self, other ):
        if isinstance( other, Image ):
           return Subtract( self, other )
        try:
           return Subtract( self, float(other) )
        except ValueError:
           return NotImplemented
    def __mul__( self, other ):
        if isinstance( other, Image ):
           return Multiply( self, other )
        try:
           return Multiply( self, float(other) )
        except ValueError:
           return NotImplemented
    def __div__( self, other ):
        if isinstance( other, Image ):
           return Divide( self, other )
        try:
           return Divide( self, float(other) )
        except ValueError:
           return NotImplemented
    def __floordiv__( self, other ):
        if isinstance( other, Image ):
           return DivideFloor( self, other )
        try:
           return DivideFloor( self, float(other) )
        except ValueError:
           return NotImplemented
    def __truediv__( self, other ):
        if isinstance( other, Image ):
           return DivideReal( self, other )
        try:
           return DivideReal( self, float(other) )
        except ValueError:
           return NotImplemented


    def __neg__( self ):
        return UnaryMinus( self )
    def __pos__( self ):
        return self

    # NOTE: for the reverse methods other cannot be an image, so
    # therefore other should be able to be considered a constant.

    def __radd__( self, other ):
        try:
           return Add( float(other), self )
        except ValueError:
           return NotImplemented
    def __rsub__( self, other ):
        try:
           return Subtract( float(other), self )
        except ValueError:
           return NotImplemented
    def __rmul__( self, other ):
        try:
           return Multiply( float(other), self )
        except ValueError:
           return NotImplemented
    def __rdiv__( self, other ):
        try:
           return Divide( float(other), self )
        except ValueError:
           return NotImplemented
    def __rfloordiv__( self, other ):
        try:
           return DivideFloor( float(other), self )
        except ValueError:
           return NotImplemented
    def __rtruediv__( self, other ):
        try:
           return DivideReal( float(other), self )
        except ValueError:
           return NotImplemented


    # logic operators

    def __and__( self, other ):
        if isinstance( other, Image ):
           return And( self, other )
        try:
           return And( self, int(other) )
        except ValueError:
           return NotImplemented
    def __rand__( self, other ):
        try:
           return And( int(other), self )
        except ValueError:
           return NotImplemented
    def __or__( self, other ):
        if isinstance( other, Image ):
           return Or( self, other )
        try:
           return Or( self, int(other) )
        except ValueError:
           return NotImplemented
    def __ror__( self, other ):
        try:
           return Or( int(other), self )
        except ValueError:
           return NotImplemented
    def __xor__( self, other ):
        if isinstance( other, Image ):
           return Xor( self, other )
        try:
           return Xor( self, int(other) )
        except ValueError:
           return NotImplemented
    def __rxor__( self, other ):
        try:
           return Xor( int(other), self )
        except ValueError:
           return NotImplemented
    def __invert__( self ): return BitwiseNot( self )

    # Relational and Equality operators

    def __lt__( self, other ):
        if isinstance( other, Image ):
           return Less( self, other )
        try:
           return Less( self, float(other) )
        except (ValueError, TypeError):
           return NotImplemented
    def __le__( self, other ):
        if isinstance( other, Image ):
           return LessEqual( self, other )
        try:
           return LessEqual( self, float(other) )
        except (ValueError, TypeError):
           return NotImplemented
    def __eq__( self, other ):
        if isinstance( other, Image ):
           return Equal( self, other )
        try:
           return Equal( self, float(other) )
        except (ValueError, TypeError):
           return NotImplemented
    def __ne__( self, other ):
        if isinstance( other, Image ):
           return NotEqual( self, other )
        try:
           return NotEqual( self, float(other) )
        except (ValueError, TypeError):
           return NotImplemented
    def __gt__( self, other ):
        if isinstance( other, Image ):
           return Greater( self, other )
        try:
           return Greater( self, float(other) )
        except (ValueError, TypeError):
           return NotImplemented
    def __ge__( self, other ):
        if isinstance( other, Image ):
           return GreaterEqual( self, other )
        try:
           return GreaterEqual( self, float(other) )
        except (ValueError, TypeError):
           return NotImplemented


    # "function" operators

    def __pow__( self, other ):
        if isinstance( other, Image ):
           return Pow( self, other )
        try:
           return Pow( self, float(other) )
        except ValueError:
           return NotImplemented
    def __rpow__( self, other ):
        try:
           return Pow( float(other), self )
        except ValueError:
           return NotImplemented
    def __mod__( self, other ):
        if isinstance( other, Image ):
           return Modulus( self, other )
        try:
           return Modulus( self, float(other) )
        except ValueError:
           return NotImplemented
    def __abs__( self ):
        return Abs( self )

    # iterator and container methods

    def __iter__( self ):

        if len(self) == 0:
          return

        dim = self.GetDimension()
        size = self.GetSize()
        idx = [0] * dim

        while idx[dim-1] < size[dim-1]:

          yield self[ idx ]

    # increment the idx
          for d in range( 0, dim ):
            idx[d] += 1
            if idx[d] >= size[d] and d != dim  - 1:
               idx[d] = 0
            else:
               break

        return

    def __len__( self ):
        l = 1
        for ds in self.GetSize():
          l *= ds
        return l

    # set/get pixel methods

    def __delitem__( self, key ):
        """Remove an item from the meta-data dictionary.

        It is an exception to delete the "origin", "spacing" and "direction" reserved keys.

        If the key does not exist in the dictionary no action or exception occours.
        """
        if not isinstance(key, str):
          raise TypeError("MetaData dictionary key must be str")
        if key in [ 'origin', 'spacing', 'direction' ]:
          raise KeyError(f"'{key} is read-only")
        return self.EraseMetaData( key )


    def __contains__( self, key ):
        """Test if key is contained in the meta-data dictionary.
        """
        if not isinstance(key, str):
          raise TypeError("MetaData dictionary key must be str")
        return key in [ 'origin', 'spacing', 'direction' ] or self.HasMetaDataKey( key )

    def _expand_ellipsis(self, idx):
        """Expand "..." in idx with slice(None) to fill to dimension."""
        if Ellipsis in idx:
          if idx.count(Ellipsis) > 1:
            raise IndexError("an index can only have one ellipses ('...')")
          nidx = []
          for i in range(len(idx)):
            if idx[i] is Ellipsis:
              dim = self.GetDimension()
              nidx.extend( [slice(None)]*(dim - len(idx) + 1) )
            else:
              nidx.append(idx[i])
          return tuple(nidx)
        return tuple(idx)


    def __getitem__( self, idx ):
        """ Get an pixel value, a sliced image, or a metadata item

        This operator implements basic indexing where idx is
        arguments or a squence of integers the same dimension as
        the image. The result will be a pixel value from that
        index.

        Multi-dimension extended slice based indexing is also
        implemented. The return is a copy of a new image. The
        standard sliced based indices are supported including
        negative indices, to indicate location relative to the
        end, along with negative step sized to indicate reversing
        of direction.

        If the length of idx is less than the number of dimension
        of the image it will be padded with the defaults slice
        ":".

        When an index element is an integer, that dimension is
        collapsed extracting an image with reduced dimensionality.
        The minimum dimension of an image which can be extracted
        is 2D.

        If indexing with a string, then the metadata dictionary
        queried with the index as the key. If the metadata dictionary
        does not contain the key, a KeyError will occour.
        """

        if isinstance(idx, str):
          if idx == 'origin':
            return self.GetOrigin()
          elif idx == 'spacing':
            return self.GetSpacing()
          elif idx == 'direction':
            return self.GetDirection()
          else:
            try:
              return self.GetMetaData(idx)
            except RuntimeError as e:
                if not self.HasMetaDataKey( idx ):
                  raise KeyError(f"\"{idx}\" not in meta-data dictionary")
                raise e

        if sys.version_info[0] < 3:
          def isint( i ):
            return type(i) == int or type(i) == long
        else:
          def isint( i ):
            return type(i) == int

        dim = self.GetDimension()
        size = self.GetSize()

        try:
          len(idx)
        except TypeError as e:
    # if the len function did not work then, assume is a
    # non-iterable, and make it a single element then an ...
          if idx == Ellipsis:
            idx = (Ellipsis,)
          else:
            idx = (idx, Ellipsis)

        if len(idx) > dim + (Ellipsis in idx):
          raise IndexError("too many indices for image")
        if (len(idx) < dim) and Ellipsis not in idx:
    # if the argument tuple has fewer elements then the dimension of the image then extend to match that of the image
          idx = tuple(idx) + (Ellipsis,)

        idx = self._expand_ellipsis(idx)

    # All the indices are integers just return GetPixel value
        if all( isint(i) for i in idx ):
    # if any of the arguments are negative integers subract them for the size
          idx = [idx[i] if idx[i] >= 0 else (size[i] + idx[i]) for i in range(len(idx))]

          for i in range(len(idx)):
            if idx[i] < 0 or idx[i] >= size[i]:
              raise IndexError("index {0} is outside the extent for dimension {1} with size {2}".format( idx[i], i, size[i]))

          return self.GetPixel(*tuple(idx))


    # If an index is an integer then we are extracting to a small dimension
        slice_dims = []
        for i in range(len(idx)):
          if type(idx[i]) is slice:
            continue
          elif isint(idx[i]):
            slice_dims.append(i)

            s = idx[i]
            if s < 0:
              s += size[i]
            if s < 0 or s >= size[i]:
              raise IndexError("index {0} is outside the extent for dimension {1} with size {2}".format( idx[i], i, size[i]))


            idx = tuple(idx[:i]) + (slice(s, s+1),)+ tuple(idx[i+1:])

        if dim - len(slice_dims) < 2:
          raise IndexError("invalid slice extraction to 1 dimension")


    # Use the slice filter when all the elements are slices ( or have been processed to be )
        if all( type(i) is slice for i in idx ):

    # perform standard slice indexing, to clamp to ranges and add in defaults
          sidx = [ idx[i].indices(size[i]) for i in range(len(idx ))]

    # extract each element of the indices rages together
          (start, stop, step) = zip(*sidx)

    # run the slice filter
          img = Slice(self, start=start, stop=stop, step=step)

          if slice_dims:
            size = img.GetSize();

    # set the slice dimension size to 0
            for i in slice_dims:
              size = tuple(size[:i]) + (0,) + tuple(size[i+1:])

    # Reduce the dimension of the image
            img = Extract( img, size )

          return img


    # the index parameter was an invalid set of objects
        raise IndexError("invalid index")


    def __setitem__( self, idx, rvalue ):
        """Sets this image's pixel value(s) to rvalue.

        The dimension of idx must match that of the image.

        If all indices are integers then rvalue should be a pixel value
        ( scalar or sequence for vector pixels). The value is assigned to
        the pixel.

        If idx is an image, it is considered a binary mask of 0s and non-zeros.
        The pixels corresponding to the non-zeros of the mask are assigned
        values. If rvalue is a scalar constant the scalar value is assigned to
        the pixel. If rvalue is an image then the corresponding pixel is
        assigned. All images involved in the operation must have congruent
        geometry.

        If the indices are slices or integers then, the PasteImageFilter is
        used to assign values to this image. The rvalue can be an image
        or a scalar constant value. When rvalue is an image it must be of
        the same pixel type and equal or lesser dimension than self. The
        region defined by idx and rvalue's size must be compatible. The
        region defined by idx will collapse one sized idx dimensions when it
        does not match the rvalue image's size.
        """

        if isinstance(idx, str):
          if idx == 'origin':
            return self.SetOrigin(rvalue)
          elif idx == 'spacing':
            return self.SetSpacing(rvalue)
          elif idx == 'direction':
            return self.SetDirection(rvalue)
          else:
            if not isinstance(rvalue, str):
              raise TypeError("metadata item must be a string")
            return self.SetMetaData(idx, rvalue)

        if isinstance(idx, Image):
           return self.__imasked_assign(idx, rvalue)

        if sys.version_info[0] < 3:
          def isint( i ):
            return type(i) == int or type(i) == long
        else:
          def isint( i ):
            return type(i) == int

        dim = self.GetDimension()
        size = self.GetSize()

        try:
          len(idx)
        except TypeError as e:
    # if the len function did not work then, assume is a
    # non-iterable, and make it a single element then an ...
          if idx == Ellipsis:
            idx = (Ellipsis,)
          else:
            idx = (idx, Ellipsis)

        if len(idx) > dim + (Ellipsis in idx):
          raise IndexError("too many indices for image")
        if (len(idx) < dim) and Ellipsis not in idx:
    # if the argument tuple has fewer elements then the dimension of the image then extend to match that of the image
          idx = tuple(idx) + (Ellipsis,)

        idx = self._expand_ellipsis(idx)

    # All the indices are integers use SetPixel
        if all( isint(i) for i in idx ):
    # if any of the arguments are negative integers subract them from the size
          idx = [idx[i] if idx[i] >= 0 else (size[i] + idx[i]) for i in range(len(idx))]

          for i in range(len(idx)):
            if idx[i] < 0 or idx[i] >= size[i]:
              raise IndexError("index {0} is outside the extent for dimension {1} with size {2}".format( idx[i], i, size[i]))

          return self.SetPixel(*(tuple(idx)+(rvalue,)))

        for i in range(len(idx)):
          if type(idx[i]) is slice:
            continue
          elif isint(idx[i]):
            s = idx[i]
            if s < 0:
              s += size[i]
            if s < 0 or s >= size[i]:
              raise IndexError("index {0} is outside the extent for dimension {1} with size {2}".format( idx[i], i, size[i]))

            idx = tuple(idx[:i]) + (slice(s, s+1),)+ tuple(idx[i+1:])

        if all( type(i) is slice for i in idx ):
          sidx = [ idx[i].indices(size[i]) for i in range(len(idx ))]

          (start, stop, step) = zip(*sidx)
          size = [ e-b for b, e in zip(start, stop) ]
          try:
            sourceSize = rvalue.GetSize()
          except AttributeError:
            sourceSize = size

          for i in range(dim):
            if step[i] != 1:
              raise IndexError("step {0} is not 1 for dimension {1}".format(step[i], i))

          skipAxes = [False] * dim

          s = 0;
          for i in range(dim):

            if size[i] == 1 and (len(sourceSize) <= s or sourceSize[s] != size[i]):
              skipAxes[i] = True
              continue

            if len(sourceSize) <= s  or sourceSize[s] != size[i]:
              raise IndexError("cannot paste source with size {0} into destination with size {1}".format(size, sourceSize))
            s += 1

          size = [ sz for sz,skip  in zip(size, skipAxes) if not skip ]
          return self.__ipaste( rvalue, size, [0]*len(size), start, skipAxes)

    # the index parameter was an invalid set of objects
        raise IndexError("invalid index with types: {0}".format([type(i) for i in idx]))


    def GetPixel(self, *idx):
      """Returns the value of a pixel.

         This method takes 2 parameters in 2D: the x and y index,
         and 3 parameters in 3D: the x, y and z index."""

      if len(idx) == 1:
       idx = idx[0]

      pixelID = self.GetPixelIDValue()
      if pixelID == sitkUnknown:
        raise Exception("invalid pixel type")
      if pixelID == sitkInt8:
        return self.__GetPixelAsInt8__( idx )
      if pixelID == sitkUInt8 or pixelID == sitkLabelUInt8:
        return self.__GetPixelAsUInt8__( idx )
      if pixelID == sitkInt16:
        return self.__GetPixelAsInt16__( idx )
      if pixelID == sitkUInt16 or pixelID == sitkLabelUInt16:
        return self.__GetPixelAsUInt16__( idx )
      if pixelID == sitkInt32:
        return self.__GetPixelAsInt32__( idx )
      if pixelID == sitkUInt32 or pixelID == sitkLabelUInt32:
        return self.__GetPixelAsUInt32__( idx )
      if pixelID == sitkInt64:
        return self.__GetPixelAsInt64__( idx )
      if pixelID == sitkUInt64 or pixelID == sitkLabelUInt64:
        return self.__GetPixelAsUInt64__( idx )
      if pixelID == sitkFloat32:
        return self.__GetPixelAsFloat__( idx )
      if pixelID == sitkFloat64:
        return self.__GetPixelAsDouble__( idx )

      if pixelID == sitkVectorInt8:
        return self.__GetPixelAsVectorInt8__( idx )
      if pixelID == sitkVectorUInt8:
        return self.__GetPixelAsVectorUInt8__( idx )
      if pixelID == sitkVectorInt16:
        return self.__GetPixelAsVectorInt16__( idx )
      if pixelID == sitkVectorUInt16:
        return self.__GetPixelAsVectorUInt16__( idx )
      if pixelID == sitkVectorInt32:
        return self.__GetPixelAsVectorInt32__( idx )
      if pixelID == sitkVectorUInt32:
        return self.__GetPixelAsVectorUInt32__( idx )
      if pixelID == sitkVectorInt64:
        return self.__GetPixelAsVectorInt64__( idx )
      if pixelID == sitkVectorUInt64:
        return self.__GetPixelAsVectorUInt64__( idx )
      if pixelID == sitkVectorFloat32:
        return self.__GetPixelAsVectorFloat32__( idx )
      if pixelID == sitkVectorFloat64:
        return self.__GetPixelAsVectorFloat64__( idx )

      if pixelID == sitkComplexFloat32:
        return self.__GetPixelAsComplexFloat32__( idx )
      if pixelID == sitkComplexFloat64:
        return self.__GetPixelAsComplexFloat64__( idx )

      raise Exception("unknown pixel type")

    def SetPixel(self, *args):
      """Sets the value of a pixel.

       This method takes 3 parameters in 2D: the x and y index then the value,
       and 4 parameters in 3D: the x, y and z index then the value."""


      pixelID = self.GetPixelIDValue()
      if pixelID == sitkUnknown:
        raise Exception("invalid pixel type")

      if len(args) < 2:
        raise Exception( "Wrong number of arguments, coordinates arguments then value" )
      idx = args[:len(args)-1]
      if len(idx) == 1:
        idx = idx[0]
      value = args[-1]

      if pixelID == sitkInt8:
        return self.__SetPixelAsInt8__( idx, value )
      if pixelID == sitkUInt8 or pixelID == sitkLabelUInt8:
        return self.__SetPixelAsUInt8__( idx, value )
      if pixelID == sitkInt16:
        return self.__SetPixelAsInt16__( idx, value )
      if pixelID == sitkUInt16 or pixelID == sitkLabelUInt16:
        return self.__SetPixelAsUInt16__( idx, value )
      if pixelID == sitkInt32:
        return self.__SetPixelAsInt32__( idx, value )
      if pixelID == sitkUInt32 or pixelID == sitkLabelUInt32:
        return self.__SetPixelAsUInt32__( idx, value )
      if pixelID == sitkInt64:
        return self.__SetPixelAsInt64__( idx, value )
      if pixelID == sitkUInt64 or pixelID == sitkLabelUInt64:
        return self.__SetPixelAsUInt64__( idx, value )
      if pixelID == sitkFloat32:
        return self.__SetPixelAsFloat__( idx, value )
      if pixelID == sitkFloat64:
        return self.__SetPixelAsDouble__( idx, value )

      if pixelID == sitkVectorInt8:
        return self.__SetPixelAsVectorInt8__( idx, value )
      if pixelID == sitkVectorUInt8:
        return self.__SetPixelAsVectorUInt8__( idx, value )
      if pixelID == sitkVectorInt16:
        return self.__SetPixelAsVectorInt16__( idx, value )
      if pixelID == sitkVectorUInt16:
        return self.__SetPixelAsVectorUInt16__( idx, value )
      if pixelID == sitkVectorInt32:
        return self.__SetPixelAsVectorInt32__( idx, value )
      if pixelID == sitkVectorUInt32:
        return self.__SetPixelAsVectorUInt32__( idx, value )
      if pixelID == sitkVectorInt64:
        return self.__SetPixelAsVectorInt64__( idx, value )
      if pixelID == sitkVectorUInt64:
        return self.__SetPixelAsVectorUInt64__( idx, value )
      if pixelID == sitkVectorFloat32:
        return self.__SetPixelAsVectorFloat32__( idx, value )
      if pixelID == sitkVectorFloat64:
        return self.__SetPixelAsVectorFloat64__( idx, value )

      if pixelID == sitkComplexFloat32:
        return self.__SetPixelAsComplexFloat32__( idx, value )
      if pixelID == sitkComplexFloat64:
        return self.__SetPixelAsComplexFloat64__( idx, value )

      raise Exception("unknown pixel type")

    @staticmethod
    def _tuple_to_py_type(v, pixelID):
      if pixelID in (sitkComplexFloat32, sitkComplexFloat64):
          return complex(*v)
      elif pixelID in (sitkVectorUInt8, sitkVectorInt8,
                       sitkVectorUInt16, sitkVectorInt16,
                       sitkVectorUInt32, sitkVectorInt32,
                       sitkVectorUInt64, sitkVectorInt64,
                       sitkVectorFloat32, sitkVectorFloat64):
          return v
      elif pixelID in (sitkUInt8, sitkInt8,
                       sitkUInt16, sitkInt16,
                       sitkUInt32, sitkInt32,
                       sitkUInt64, sitkInt64,
                       sitkFloat32, sitkFloat64,
                       sitkLabelUInt8,
                       sitkLabelUInt16,
                       sitkLabelUInt32,
                       sitkLabelUInt64):
        assert(len(v)==1)
        return v[0]
      else:
        raise ValueError(f"pixelID of {pixelID} is not supported.")

    def EvaluateAtContinuousIndex(self, index, interp = sitkLinear):
      """Interpolate pixel value at a continuous index.

      This method is not supported for Label pixel types.

      The valid range of continuous index is [-0.5, size-0.5] for each dimension. An exception is thrown if index is out of bounds.

      Parameters
      ----------
      index
        The continuous index must be at least the length of the image dimension.
      interp
        The interpolation type to use, only sitkNearest and sitkLinear are supported for Vector and Complex pixel types.

      Returns
      -------
        The results will be of type float, complex, or an tuple of float of vectors.

      """

      r = self.__EvaluateAtContinuousIndex__(index, interp)

      return self._tuple_to_py_type(r, self.GetPixelIDValue())

    def EvaluateAtPhysicalPoint(self, point, interp = sitkLinear):
      """ Interpolate pixel value at a physical point.

      This method is not supported for Label pixel types.

      An exception is thrown if the point is out of the defined region for the image.

      Parameters
      ----------
      point
        The physical point at which the interpolation is computed.
      interp
        The interpolation type to use, only sitkNearest and sitkLinear are supported for Vector and Complex pixel types.

      Returns
      -------
        The results will be of type float, complex, or an tuple of float of vectors.
      """

      r = self.__EvaluateAtPhysicalPoint__(point, interp)

      return self._tuple_to_py_type(r, self.GetPixelIDValue())



# Register Image in _SimpleITK:
_SimpleITK.Image_swigregister(Image)
class ObjectOwnedBase(object):
    r"""Proxy of C++ slicer_itk::simple::ObjectOwnedBase class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ObjectOwnedBase

    def GetName(self):
        r"""GetName(ObjectOwnedBase self) -> std::string"""
        return _SimpleITK.ObjectOwnedBase_GetName(self)

    def SetName(self, name):
        r"""SetName(ObjectOwnedBase self, std::string const & name)"""
        return _SimpleITK.ObjectOwnedBase_SetName(self, name)

# Register ObjectOwnedBase in _SimpleITK:
_SimpleITK.ObjectOwnedBase_swigregister(ObjectOwnedBase)
class Command(ObjectOwnedBase):
    r"""Proxy of C++ slicer_itk::simple::Command class."""

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

    def __init__(self):
        r"""__init__(Command self) -> Command"""
        if self.__class__ == Command:
            _self = None
        else:
            _self = self
        _SimpleITK.Command_swiginit(self, _SimpleITK.new_Command(_self, ))
    __swig_destroy__ = _SimpleITK.delete_Command

    def GetName(self):
        r"""GetName(Command self) -> std::string"""
        return _SimpleITK.Command_GetName(self)

    def SetName(self, n):
        r"""SetName(Command self, std::string const & n)"""
        return _SimpleITK.Command_SetName(self, n)

    def Execute(self):
        r"""Execute(Command self)"""
        return _SimpleITK.Command_Execute(self)
    def __disown__(self):
        self.this.disown()
        _SimpleITK.disown_Command(self)
        return weakref.proxy(self)

# Register Command in _SimpleITK:
_SimpleITK.Command_swigregister(Command)
class LoggerBase(ObjectOwnedBase):
    r"""Proxy of C++ slicer_itk::simple::LoggerBase class."""

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

    def __init__(self):
        r"""__init__(LoggerBase self) -> LoggerBase"""
        if self.__class__ == LoggerBase:
            _self = None
        else:
            _self = self
        _SimpleITK.LoggerBase_swiginit(self, _SimpleITK.new_LoggerBase(_self, ))
    __swig_destroy__ = _SimpleITK.delete_LoggerBase

    def DisplayText(self, t):
        r"""DisplayText(LoggerBase self, char const * t)"""
        return _SimpleITK.LoggerBase_DisplayText(self, t)

    def DisplayErrorText(self, t):
        r"""DisplayErrorText(LoggerBase self, char const * t)"""
        return _SimpleITK.LoggerBase_DisplayErrorText(self, t)

    def DisplayWarningText(self, t):
        r"""DisplayWarningText(LoggerBase self, char const * t)"""
        return _SimpleITK.LoggerBase_DisplayWarningText(self, t)

    def DisplayGenericOutputText(self, t):
        r"""DisplayGenericOutputText(LoggerBase self, char const * t)"""
        return _SimpleITK.LoggerBase_DisplayGenericOutputText(self, t)

    def DisplayDebugText(self, t):
        r"""DisplayDebugText(LoggerBase self, char const * t)"""
        return _SimpleITK.LoggerBase_DisplayDebugText(self, t)

    def GetName(self):
        r"""GetName(LoggerBase self) -> std::string"""
        return _SimpleITK.LoggerBase_GetName(self)

    def SetName(self, n):
        r"""SetName(LoggerBase self, std::string const & n)"""
        return _SimpleITK.LoggerBase_SetName(self, n)

    def SetAsGlobalITKLogger(self):
        r"""SetAsGlobalITKLogger(LoggerBase self) -> ITKLogger"""
        return _SimpleITK.LoggerBase_SetAsGlobalITKLogger(self)

    @staticmethod
    def GetGlobalITKLogger():
        r"""GetGlobalITKLogger() -> ITKLogger"""
        return _SimpleITK.LoggerBase_GetGlobalITKLogger()
    def __disown__(self):
        self.this.disown()
        _SimpleITK.disown_LoggerBase(self)
        return weakref.proxy(self)

# Register LoggerBase in _SimpleITK:
_SimpleITK.LoggerBase_swigregister(LoggerBase)

def LoggerBase_GetGlobalITKLogger():
    r"""LoggerBase_GetGlobalITKLogger() -> ITKLogger"""
    return _SimpleITK.LoggerBase_GetGlobalITKLogger()

class ITKLogger(LoggerBase):
    r"""Proxy of C++ slicer_itk::simple::ITKLogger class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ITKLogger

    def __init__(self, *args):
        r"""
        __init__(ITKLogger self, slicer_itk::OutputWindow * arg2) -> ITKLogger
        __init__(ITKLogger self) -> ITKLogger
        __init__(ITKLogger self, ITKLogger arg2) -> ITKLogger
        """
        _SimpleITK.ITKLogger_swiginit(self, _SimpleITK.new_ITKLogger(*args))

    def DisplayText(self, t):
        r"""DisplayText(ITKLogger self, char const * t)"""
        return _SimpleITK.ITKLogger_DisplayText(self, t)

    def DisplayErrorText(self, t):
        r"""DisplayErrorText(ITKLogger self, char const * t)"""
        return _SimpleITK.ITKLogger_DisplayErrorText(self, t)

    def DisplayWarningText(self, t):
        r"""DisplayWarningText(ITKLogger self, char const * t)"""
        return _SimpleITK.ITKLogger_DisplayWarningText(self, t)

    def DisplayGenericOutputText(self, t):
        r"""DisplayGenericOutputText(ITKLogger self, char const * t)"""
        return _SimpleITK.ITKLogger_DisplayGenericOutputText(self, t)

    def DisplayDebugText(self, t):
        r"""DisplayDebugText(ITKLogger self, char const * t)"""
        return _SimpleITK.ITKLogger_DisplayDebugText(self, t)

    def SetAsGlobalITKLogger(self):
        r"""SetAsGlobalITKLogger(ITKLogger self) -> ITKLogger"""
        return _SimpleITK.ITKLogger_SetAsGlobalITKLogger(self)

# Register ITKLogger in _SimpleITK:
_SimpleITK.ITKLogger_swigregister(ITKLogger)
sitkAnnulus = _SimpleITK.sitkAnnulus

sitkBall = _SimpleITK.sitkBall

sitkBox = _SimpleITK.sitkBox

sitkCross = _SimpleITK.sitkCross

sitkPolygon3 = _SimpleITK.sitkPolygon3

sitkPolygon4 = _SimpleITK.sitkPolygon4

sitkPolygon5 = _SimpleITK.sitkPolygon5

sitkPolygon6 = _SimpleITK.sitkPolygon6

sitkPolygon7 = _SimpleITK.sitkPolygon7

sitkPolygon8 = _SimpleITK.sitkPolygon8

sitkPolygon9 = _SimpleITK.sitkPolygon9

sitkAnyEvent = _SimpleITK.sitkAnyEvent

sitkAbortEvent = _SimpleITK.sitkAbortEvent

sitkDeleteEvent = _SimpleITK.sitkDeleteEvent

sitkEndEvent = _SimpleITK.sitkEndEvent

sitkIterationEvent = _SimpleITK.sitkIterationEvent

sitkProgressEvent = _SimpleITK.sitkProgressEvent

sitkStartEvent = _SimpleITK.sitkStartEvent

sitkMultiResolutionIterationEvent = _SimpleITK.sitkMultiResolutionIterationEvent

sitkUserEvent = _SimpleITK.sitkUserEvent

sitkWallClock = _SimpleITK.sitkWallClock

sitkUnknownTransform = _SimpleITK.sitkUnknownTransform

sitkIdentity = _SimpleITK.sitkIdentity

sitkTranslation = _SimpleITK.sitkTranslation

sitkScale = _SimpleITK.sitkScale

sitkScaleLogarithmic = _SimpleITK.sitkScaleLogarithmic

sitkEuler = _SimpleITK.sitkEuler

sitkSimilarity = _SimpleITK.sitkSimilarity

sitkQuaternionRigid = _SimpleITK.sitkQuaternionRigid

sitkVersor = _SimpleITK.sitkVersor

sitkVersorRigid = _SimpleITK.sitkVersorRigid

sitkScaleSkewVersor = _SimpleITK.sitkScaleSkewVersor

sitkComposeScaleSkewVersor = _SimpleITK.sitkComposeScaleSkewVersor

sitkScaleVersor = _SimpleITK.sitkScaleVersor

sitkAffine = _SimpleITK.sitkAffine

sitkComposite = _SimpleITK.sitkComposite

sitkDisplacementField = _SimpleITK.sitkDisplacementField

sitkBSplineTransform = _SimpleITK.sitkBSplineTransform

class Transform(object):
    r"""Proxy of C++ slicer_itk::simple::Transform class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_Transform

    def __init__(self, *args):
        r"""
        __init__(Transform self) -> Transform
        __init__(Transform self, slicer_itk::TransformBase * transform) -> Transform
        __init__(Transform self, unsigned int dimensions, slicer_itk::simple::TransformEnum type) -> Transform
        __init__(Transform self, Image displacement, slicer_itk::simple::TransformEnum type=sitkDisplacementField) -> Transform
        __init__(Transform self, Transform arg2) -> Transform
        """
        _SimpleITK.Transform_swiginit(self, _SimpleITK.new_Transform(*args))

    def GetITKBase(self, *args):
        r"""
        GetITKBase(Transform self) -> slicer_itk::TransformBase
        GetITKBase(Transform self) -> slicer_itk::TransformBase const *
        """
        return _SimpleITK.Transform_GetITKBase(self, *args)

    def GetDimension(self):
        r"""GetDimension(Transform self) -> unsigned int"""
        return _SimpleITK.Transform_GetDimension(self)

    def SetParameters(self, parameters):
        r"""SetParameters(Transform self, VectorDouble parameters)"""
        return _SimpleITK.Transform_SetParameters(self, parameters)

    def GetParameters(self):
        r"""GetParameters(Transform self) -> VectorDouble"""
        return _SimpleITK.Transform_GetParameters(self)

    def GetNumberOfParameters(self):
        r"""GetNumberOfParameters(Transform self) -> unsigned int"""
        return _SimpleITK.Transform_GetNumberOfParameters(self)

    def SetFixedParameters(self, parameters):
        r"""SetFixedParameters(Transform self, VectorDouble parameters)"""
        return _SimpleITK.Transform_SetFixedParameters(self, parameters)

    def GetFixedParameters(self):
        r"""GetFixedParameters(Transform self) -> VectorDouble"""
        return _SimpleITK.Transform_GetFixedParameters(self)

    def GetNumberOfFixedParameters(self):
        r"""GetNumberOfFixedParameters(Transform self) -> unsigned int"""
        return _SimpleITK.Transform_GetNumberOfFixedParameters(self)

    def TransformPoint(self, point):
        r"""TransformPoint(Transform self, VectorDouble point) -> VectorDouble"""
        return _SimpleITK.Transform_TransformPoint(self, point)

    def TransformVector(self, vector, point):
        r"""TransformVector(Transform self, VectorDouble vector, VectorDouble point) -> VectorDouble"""
        return _SimpleITK.Transform_TransformVector(self, vector, point)

    def WriteTransform(self, filename):
        r"""WriteTransform(Transform self, std::string const & filename)"""
        return _SimpleITK.Transform_WriteTransform(self, filename)

    def IsLinear(self):
        r"""IsLinear(Transform self) -> bool"""
        return _SimpleITK.Transform_IsLinear(self)

    def SetIdentity(self):
        r"""SetIdentity(Transform self)"""
        return _SimpleITK.Transform_SetIdentity(self)

    def SetInverse(self):
        r"""SetInverse(Transform self) -> bool"""
        return _SimpleITK.Transform_SetInverse(self)

    def GetInverse(self):
        r"""GetInverse(Transform self) -> Transform"""
        val = _SimpleITK.Transform_GetInverse(self)

        val = val.Downcast()


        return val


    def __str__(self):
        r"""__str__(Transform self) -> std::string"""
        return _SimpleITK.Transform___str__(self)

    def GetName(self):
        r"""GetName(Transform self) -> std::string"""
        return _SimpleITK.Transform_GetName(self)

    def MakeUnique(self):
        r"""MakeUnique(Transform self)"""
        return _SimpleITK.Transform_MakeUnique(self)

    def GetTransformEnum(self):
        r"""GetTransformEnum(Transform self) -> slicer_itk::simple::TransformEnum"""
        return _SimpleITK.Transform_GetTransformEnum(self)


    def __copy__(self):
      """Create a SimpleITK shallow copy, where the internal transform is shared with a copy on write implementation."""
      return self.__class__(self)

    def __deepcopy__(self, memo):
      """Create a new copy of the data and internal ITK Transform object."""
      dc = self.__class__(self)
      dc.MakeUnique()
      return dc

    def __setstate__(self, args):
      if args[0] != 0:
        raise ValueError("Unable to handle SimpleITK.Transform pickle version {0}".args[0])

      if len(args) == 1:
        return

      state = namedtuple('state_tuple_0', "version fixed_parameters parameters")(*args)

      self.SetFixedParameters(state.fixed_parameters)
      self.SetParameters(state.parameters)


    def __reduce_ex__(self, protocol):
      version = 0

      downcasted = self.Downcast()

      if downcasted.__class__ is DisplacementFieldTransform:
        dis = downcasted.GetDisplacementField()
        if all( 0 == s for s in dis.GetSize() ):
    # The null state needs special handling
            args = (downcasted.GetDimension(),)
            S = (version, downcasted.GetFixedParameters(), downcasted.GetParameters())
        else:
            args = (dis, )
            S = (version, )
      elif downcasted.__class__ is BSplineTransform:
        args = (tuple(downcasted.GetCoefficientImages()), downcasted.GetOrder())
        S = (version, )
      elif downcasted.__class__ == CompositeTransform:
        if downcasted.GetNumberOfTransforms() > 0:
           args = ([ downcasted.GetNthTransform(n) for n in range(downcasted.GetNumberOfTransforms()) ], )
        else:
           args = (downcasted.GetDimension(),)
        S = (version, )

      else:
        args = ()
        if downcasted.__class__ in [AffineTransform, ScaleTransform, TranslationTransform]:
            args = (downcasted.GetDimension(),)
        elif downcasted.__class__ is Transform:
            args = (downcasted.GetDimension(), downcasted.GetTransformEnum())

        S = (version, downcasted.GetFixedParameters(), downcasted.GetParameters())

      return downcasted.__class__, args, S

    def Downcast(self):
        """Convert to the appropriate derived SimpleITK object. A lazy copy to
        the underlying ITK object is performed. """

        transform_downcast_map  = {
            sitkUnknownTransform: (None, None),
            sitkIdentity: (Transform, Transform),
            sitkTranslation: (TranslationTransform, TranslationTransform),
            sitkScale: (ScaleTransform, ScaleTransform),
            sitkScaleLogarithmic: (Transform, Transform),
            sitkEuler: (Euler2DTransform, Euler3DTransform),
            sitkSimilarity: (Similarity2DTransform, Similarity3DTransform),
            sitkQuaternionRigid: (None, Transform),
            sitkVersor: (None, VersorTransform),
            sitkVersorRigid: ( None, VersorRigid3DTransform),
            sitkScaleSkewVersor: ( None, ScaleSkewVersor3DTransform),
            sitkScaleVersor: ( None, ScaleVersor3DTransform),
            sitkAffine: (AffineTransform, AffineTransform),
            sitkComposite: (CompositeTransform, CompositeTransform),
            sitkDisplacementField: (DisplacementFieldTransform, DisplacementFieldTransform),
            sitkBSplineTransform: (BSplineTransform, BSplineTransform)
        }

        id = self.GetTransformEnum()
        if id is sitkUnknownTransform:
            raise TypeError("Unknown internal ITK transform type.")
        downcast_type = transform_downcast_map[id][self.GetDimension()-2]
        if downcast_type is None:
            raise TypeError("Unable to downcast transform type.")
        return downcast_type(self)


# Register Transform in _SimpleITK:
_SimpleITK.Transform_swigregister(Transform)

def ReadTransform(filename):
    r"""ReadTransform(slicer_itk::simple::PathType const & filename) -> Transform"""
    val = _SimpleITK.ReadTransform(filename)

    val = val.Downcast()


    return val

def WriteTransform(transform, filename):
    r"""WriteTransform(Transform transform, slicer_itk::simple::PathType const & filename)"""
    return _SimpleITK.WriteTransform(transform, filename)
class BSplineTransform(Transform):
    r"""Proxy of C++ slicer_itk::simple::BSplineTransform class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BSplineTransform

    def __init__(self, *args):
        r"""
        __init__(BSplineTransform self, unsigned int dimensions, unsigned int order=3) -> BSplineTransform
        __init__(BSplineTransform self, VectorOfImage coefficientImages, unsigned int order=3) -> BSplineTransform
        __init__(BSplineTransform self, BSplineTransform arg2) -> BSplineTransform
        __init__(BSplineTransform self, Transform arg2) -> BSplineTransform
        """
        _SimpleITK.BSplineTransform_swiginit(self, _SimpleITK.new_BSplineTransform(*args))

    def GetName(self):
        r"""GetName(BSplineTransform self) -> std::string"""
        return _SimpleITK.BSplineTransform_GetName(self)

    def SetTransformDomainDirection(self, arg2):
        r"""SetTransformDomainDirection(BSplineTransform self, VectorDouble arg2)"""
        return _SimpleITK.BSplineTransform_SetTransformDomainDirection(self, arg2)

    def GetTransformDomainDirection(self):
        r"""GetTransformDomainDirection(BSplineTransform self) -> VectorDouble"""
        return _SimpleITK.BSplineTransform_GetTransformDomainDirection(self)

    def SetTransformDomainMeshSize(self, arg2):
        r"""SetTransformDomainMeshSize(BSplineTransform self, VectorUInt32 arg2)"""
        return _SimpleITK.BSplineTransform_SetTransformDomainMeshSize(self, arg2)

    def GetTransformDomainMeshSize(self):
        r"""GetTransformDomainMeshSize(BSplineTransform self) -> VectorUInt32"""
        return _SimpleITK.BSplineTransform_GetTransformDomainMeshSize(self)

    def SetTransformDomainOrigin(self, arg2):
        r"""SetTransformDomainOrigin(BSplineTransform self, VectorDouble arg2)"""
        return _SimpleITK.BSplineTransform_SetTransformDomainOrigin(self, arg2)

    def GetTransformDomainOrigin(self):
        r"""GetTransformDomainOrigin(BSplineTransform self) -> VectorDouble"""
        return _SimpleITK.BSplineTransform_GetTransformDomainOrigin(self)

    def SetTransformDomainPhysicalDimensions(self, arg2):
        r"""SetTransformDomainPhysicalDimensions(BSplineTransform self, VectorDouble arg2)"""
        return _SimpleITK.BSplineTransform_SetTransformDomainPhysicalDimensions(self, arg2)

    def GetTransformDomainPhysicalDimensions(self):
        r"""GetTransformDomainPhysicalDimensions(BSplineTransform self) -> VectorDouble"""
        return _SimpleITK.BSplineTransform_GetTransformDomainPhysicalDimensions(self)

    def GetCoefficientImages(self):
        r"""GetCoefficientImages(BSplineTransform self) -> VectorOfImage"""
        return _SimpleITK.BSplineTransform_GetCoefficientImages(self)

    def GetOrder(self):
        r"""GetOrder(BSplineTransform self) -> unsigned int"""
        return _SimpleITK.BSplineTransform_GetOrder(self)

# Register BSplineTransform in _SimpleITK:
_SimpleITK.BSplineTransform_swigregister(BSplineTransform)
class DisplacementFieldTransform(Transform):
    r"""Proxy of C++ slicer_itk::simple::DisplacementFieldTransform class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_DisplacementFieldTransform

    def __init__(self, *args):
        r"""
        __init__(DisplacementFieldTransform self, unsigned int dimensions) -> DisplacementFieldTransform
        __init__(DisplacementFieldTransform self, Image arg2) -> DisplacementFieldTransform
        __init__(DisplacementFieldTransform self, DisplacementFieldTransform arg2) -> DisplacementFieldTransform
        __init__(DisplacementFieldTransform self, Transform arg2) -> DisplacementFieldTransform
        """
        _SimpleITK.DisplacementFieldTransform_swiginit(self, _SimpleITK.new_DisplacementFieldTransform(*args))

    def GetName(self):
        r"""GetName(DisplacementFieldTransform self) -> std::string"""
        return _SimpleITK.DisplacementFieldTransform_GetName(self)

    def SetDisplacementField(self, arg2):
        r"""SetDisplacementField(DisplacementFieldTransform self, Image arg2)"""
        return _SimpleITK.DisplacementFieldTransform_SetDisplacementField(self, arg2)

    def GetDisplacementField(self):
        r"""GetDisplacementField(DisplacementFieldTransform self) -> Image"""
        return _SimpleITK.DisplacementFieldTransform_GetDisplacementField(self)

    def SetInverseDisplacementField(self, arg2):
        r"""SetInverseDisplacementField(DisplacementFieldTransform self, Image arg2)"""
        return _SimpleITK.DisplacementFieldTransform_SetInverseDisplacementField(self, arg2)

    def GetInverseDisplacementField(self):
        r"""GetInverseDisplacementField(DisplacementFieldTransform self) -> Image"""
        return _SimpleITK.DisplacementFieldTransform_GetInverseDisplacementField(self)

    def SetInterpolator(self, interp):
        r"""SetInterpolator(DisplacementFieldTransform self, slicer_itk::simple::InterpolatorEnum interp)"""
        return _SimpleITK.DisplacementFieldTransform_SetInterpolator(self, interp)

    def SetSmoothingOff(self):
        r"""SetSmoothingOff(DisplacementFieldTransform self)"""
        return _SimpleITK.DisplacementFieldTransform_SetSmoothingOff(self)

    def SetSmoothingGaussianOnUpdate(self, varianceForUpdateField=1.75, varianceForTotalField=0.5):
        r"""SetSmoothingGaussianOnUpdate(DisplacementFieldTransform self, double varianceForUpdateField=1.75, double varianceForTotalField=0.5)"""
        return _SimpleITK.DisplacementFieldTransform_SetSmoothingGaussianOnUpdate(self, varianceForUpdateField, varianceForTotalField)

    def SetSmoothingBSplineOnUpdate(self, *args, **kwargs):
        r"""SetSmoothingBSplineOnUpdate(DisplacementFieldTransform self, VectorUInt32 numberOfControlPointsForUpdateField=std::vector< unsigned int >(3, 4), VectorUInt32 numberOfControlPointsForTotalField=std::vector< unsigned int >(3, 4), bool enforceStationaryBoundary=True, unsigned int order=3)"""
        return _SimpleITK.DisplacementFieldTransform_SetSmoothingBSplineOnUpdate(self, *args, **kwargs)

# Register DisplacementFieldTransform in _SimpleITK:
_SimpleITK.DisplacementFieldTransform_swigregister(DisplacementFieldTransform)
class AffineTransform(Transform):
    r"""Proxy of C++ slicer_itk::simple::AffineTransform class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_AffineTransform

    def __init__(self, *args):
        r"""
        __init__(AffineTransform self, unsigned int dimensions) -> AffineTransform
        __init__(AffineTransform self, AffineTransform arg2) -> AffineTransform
        __init__(AffineTransform self, Transform arg2) -> AffineTransform
        __init__(AffineTransform self, VectorDouble matrix, VectorDouble translation, VectorDouble fixedCenter=std::vector< double >(3, 0.0)) -> AffineTransform
        """
        _SimpleITK.AffineTransform_swiginit(self, _SimpleITK.new_AffineTransform(*args))

    def GetName(self):
        r"""GetName(AffineTransform self) -> std::string"""
        return _SimpleITK.AffineTransform_GetName(self)

    def GetTranslation(self):
        r"""GetTranslation(AffineTransform self) -> VectorDouble"""
        return _SimpleITK.AffineTransform_GetTranslation(self)

    def SetTranslation(self, translation):
        r"""SetTranslation(AffineTransform self, VectorDouble translation)"""
        return _SimpleITK.AffineTransform_SetTranslation(self, translation)

    def SetMatrix(self, matrix):
        r"""SetMatrix(AffineTransform self, VectorDouble matrix)"""
        return _SimpleITK.AffineTransform_SetMatrix(self, matrix)

    def GetMatrix(self):
        r"""GetMatrix(AffineTransform self) -> VectorDouble"""
        return _SimpleITK.AffineTransform_GetMatrix(self)

    def SetCenter(self, params):
        r"""SetCenter(AffineTransform self, VectorDouble params)"""
        return _SimpleITK.AffineTransform_SetCenter(self, params)

    def GetCenter(self):
        r"""GetCenter(AffineTransform self) -> VectorDouble"""
        return _SimpleITK.AffineTransform_GetCenter(self)

    def Scale(self, *args):
        r"""
        Scale(AffineTransform self, VectorDouble factor, bool pre=False)
        Scale(AffineTransform self, double factor, bool pre=False)
        """
        return _SimpleITK.AffineTransform_Scale(self, *args)

    def Shear(self, axis1, axis2, coef, pre=False):
        r"""Shear(AffineTransform self, int axis1, int axis2, double coef, bool pre=False)"""
        return _SimpleITK.AffineTransform_Shear(self, axis1, axis2, coef, pre)

    def Translate(self, offset, pre=False):
        r"""Translate(AffineTransform self, VectorDouble offset, bool pre=False)"""
        return _SimpleITK.AffineTransform_Translate(self, offset, pre)

    def Rotate(self, axis1, axis2, angle, pre=False):
        r"""Rotate(AffineTransform self, int axis1, int axis2, double angle, bool pre=False)"""
        return _SimpleITK.AffineTransform_Rotate(self, axis1, axis2, angle, pre)

# Register AffineTransform in _SimpleITK:
_SimpleITK.AffineTransform_swigregister(AffineTransform)
class Euler3DTransform(Transform):
    r"""Proxy of C++ slicer_itk::simple::Euler3DTransform class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_Euler3DTransform

    def __init__(self, *args):
        r"""
        __init__(Euler3DTransform self) -> Euler3DTransform
        __init__(Euler3DTransform self, VectorDouble fixedCenter, double angleX=0.0, double angleY=0.0, double angleZ=0.0, VectorDouble translation=std::vector< double >(3, 0.0)) -> Euler3DTransform
        __init__(Euler3DTransform self, Euler3DTransform arg2) -> Euler3DTransform
        __init__(Euler3DTransform self, Transform arg2) -> Euler3DTransform
        """
        _SimpleITK.Euler3DTransform_swiginit(self, _SimpleITK.new_Euler3DTransform(*args))

    def GetName(self):
        r"""GetName(Euler3DTransform self) -> std::string"""
        return _SimpleITK.Euler3DTransform_GetName(self)

    def SetCenter(self, params):
        r"""SetCenter(Euler3DTransform self, VectorDouble params)"""
        return _SimpleITK.Euler3DTransform_SetCenter(self, params)

    def GetCenter(self):
        r"""GetCenter(Euler3DTransform self) -> VectorDouble"""
        return _SimpleITK.Euler3DTransform_GetCenter(self)

    def GetAngleX(self):
        r"""GetAngleX(Euler3DTransform self) -> double"""
        return _SimpleITK.Euler3DTransform_GetAngleX(self)

    def GetAngleY(self):
        r"""GetAngleY(Euler3DTransform self) -> double"""
        return _SimpleITK.Euler3DTransform_GetAngleY(self)

    def GetAngleZ(self):
        r"""GetAngleZ(Euler3DTransform self) -> double"""
        return _SimpleITK.Euler3DTransform_GetAngleZ(self)

    def SetRotation(self, angleX, angleY, angleZ):
        r"""SetRotation(Euler3DTransform self, double angleX, double angleY, double angleZ)"""
        return _SimpleITK.Euler3DTransform_SetRotation(self, angleX, angleY, angleZ)

    def GetTranslation(self):
        r"""GetTranslation(Euler3DTransform self) -> VectorDouble"""
        return _SimpleITK.Euler3DTransform_GetTranslation(self)

    def SetTranslation(self, translation):
        r"""SetTranslation(Euler3DTransform self, VectorDouble translation)"""
        return _SimpleITK.Euler3DTransform_SetTranslation(self, translation)

    def SetComputeZYX(self, _arg):
        r"""SetComputeZYX(Euler3DTransform self, bool _arg)"""
        return _SimpleITK.Euler3DTransform_SetComputeZYX(self, _arg)

    def GetComputeZYX(self):
        r"""GetComputeZYX(Euler3DTransform self) -> bool"""
        return _SimpleITK.Euler3DTransform_GetComputeZYX(self)

    def ComputeZYXOn(self):
        r"""ComputeZYXOn(Euler3DTransform self)"""
        return _SimpleITK.Euler3DTransform_ComputeZYXOn(self)

    def ComputeZYXOff(self):
        r"""ComputeZYXOff(Euler3DTransform self)"""
        return _SimpleITK.Euler3DTransform_ComputeZYXOff(self)

    def GetMatrix(self):
        r"""GetMatrix(Euler3DTransform self) -> VectorDouble"""
        return _SimpleITK.Euler3DTransform_GetMatrix(self)

    def SetMatrix(self, matrix, tolerance=1e-10):
        r"""SetMatrix(Euler3DTransform self, VectorDouble matrix, double tolerance=1e-10)"""
        return _SimpleITK.Euler3DTransform_SetMatrix(self, matrix, tolerance)

# Register Euler3DTransform in _SimpleITK:
_SimpleITK.Euler3DTransform_swigregister(Euler3DTransform)
class Euler2DTransform(Transform):
    r"""Proxy of C++ slicer_itk::simple::Euler2DTransform class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_Euler2DTransform

    def __init__(self, *args):
        r"""
        __init__(Euler2DTransform self) -> Euler2DTransform
        __init__(Euler2DTransform self, VectorDouble fixedCenter, double angle=0.0, VectorDouble translation=std::vector< double >(2, 0.0)) -> Euler2DTransform
        __init__(Euler2DTransform self, Euler2DTransform arg2) -> Euler2DTransform
        __init__(Euler2DTransform self, Transform arg2) -> Euler2DTransform
        """
        _SimpleITK.Euler2DTransform_swiginit(self, _SimpleITK.new_Euler2DTransform(*args))

    def GetName(self):
        r"""GetName(Euler2DTransform self) -> std::string"""
        return _SimpleITK.Euler2DTransform_GetName(self)

    def SetCenter(self, params):
        r"""SetCenter(Euler2DTransform self, VectorDouble params)"""
        return _SimpleITK.Euler2DTransform_SetCenter(self, params)

    def GetCenter(self):
        r"""GetCenter(Euler2DTransform self) -> VectorDouble"""
        return _SimpleITK.Euler2DTransform_GetCenter(self)

    def SetAngle(self, angle):
        r"""SetAngle(Euler2DTransform self, double angle)"""
        return _SimpleITK.Euler2DTransform_SetAngle(self, angle)

    def GetAngle(self):
        r"""GetAngle(Euler2DTransform self) -> double"""
        return _SimpleITK.Euler2DTransform_GetAngle(self)

    def GetTranslation(self):
        r"""GetTranslation(Euler2DTransform self) -> VectorDouble"""
        return _SimpleITK.Euler2DTransform_GetTranslation(self)

    def SetTranslation(self, translation):
        r"""SetTranslation(Euler2DTransform self, VectorDouble translation)"""
        return _SimpleITK.Euler2DTransform_SetTranslation(self, translation)

    def GetMatrix(self):
        r"""GetMatrix(Euler2DTransform self) -> VectorDouble"""
        return _SimpleITK.Euler2DTransform_GetMatrix(self)

    def SetMatrix(self, matrix, tolerance=1e-10):
        r"""SetMatrix(Euler2DTransform self, VectorDouble matrix, double tolerance=1e-10)"""
        return _SimpleITK.Euler2DTransform_SetMatrix(self, matrix, tolerance)

# Register Euler2DTransform in _SimpleITK:
_SimpleITK.Euler2DTransform_swigregister(Euler2DTransform)
class ScaleTransform(Transform):
    r"""Proxy of C++ slicer_itk::simple::ScaleTransform class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ScaleTransform

    def __init__(self, *args):
        r"""
        __init__(ScaleTransform self, unsigned int dimensions, VectorDouble scale=std::vector< double >(3, 1.0)) -> ScaleTransform
        __init__(ScaleTransform self, ScaleTransform arg2) -> ScaleTransform
        __init__(ScaleTransform self, Transform arg2) -> ScaleTransform
        """
        _SimpleITK.ScaleTransform_swiginit(self, _SimpleITK.new_ScaleTransform(*args))

    def GetName(self):
        r"""GetName(ScaleTransform self) -> std::string"""
        return _SimpleITK.ScaleTransform_GetName(self)

    def SetScale(self, params):
        r"""SetScale(ScaleTransform self, VectorDouble params)"""
        return _SimpleITK.ScaleTransform_SetScale(self, params)

    def GetScale(self):
        r"""GetScale(ScaleTransform self) -> VectorDouble"""
        return _SimpleITK.ScaleTransform_GetScale(self)

    def SetCenter(self, params):
        r"""SetCenter(ScaleTransform self, VectorDouble params)"""
        return _SimpleITK.ScaleTransform_SetCenter(self, params)

    def GetCenter(self):
        r"""GetCenter(ScaleTransform self) -> VectorDouble"""
        return _SimpleITK.ScaleTransform_GetCenter(self)

    def GetMatrix(self):
        r"""GetMatrix(ScaleTransform self) -> VectorDouble"""
        return _SimpleITK.ScaleTransform_GetMatrix(self)

# Register ScaleTransform in _SimpleITK:
_SimpleITK.ScaleTransform_swigregister(ScaleTransform)
class ScaleSkewVersor3DTransform(Transform):
    r"""Proxy of C++ slicer_itk::simple::ScaleSkewVersor3DTransform class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ScaleSkewVersor3DTransform

    def __init__(self, *args):
        r"""
        __init__(ScaleSkewVersor3DTransform self) -> ScaleSkewVersor3DTransform
        __init__(ScaleSkewVersor3DTransform self, ScaleSkewVersor3DTransform arg2) -> ScaleSkewVersor3DTransform
        __init__(ScaleSkewVersor3DTransform self, Transform arg2) -> ScaleSkewVersor3DTransform
        __init__(ScaleSkewVersor3DTransform self, VectorDouble scale, VectorDouble skew, VectorDouble versor, VectorDouble translation=std::vector< double >(3, 0.0), VectorDouble fixedCenter=std::vector< double >(3, 0.0)) -> ScaleSkewVersor3DTransform
        __init__(ScaleSkewVersor3DTransform self, VectorDouble scale, VectorDouble skew, VectorDouble axis, double angle, VectorDouble translation=std::vector< double >(3, 0.0), VectorDouble fixedCenter=std::vector< double >(3, 0.0)) -> ScaleSkewVersor3DTransform
        """
        _SimpleITK.ScaleSkewVersor3DTransform_swiginit(self, _SimpleITK.new_ScaleSkewVersor3DTransform(*args))

    def GetName(self):
        r"""GetName(ScaleSkewVersor3DTransform self) -> std::string"""
        return _SimpleITK.ScaleSkewVersor3DTransform_GetName(self)

    def SetCenter(self, params):
        r"""SetCenter(ScaleSkewVersor3DTransform self, VectorDouble params)"""
        return _SimpleITK.ScaleSkewVersor3DTransform_SetCenter(self, params)

    def GetCenter(self):
        r"""GetCenter(ScaleSkewVersor3DTransform self) -> VectorDouble"""
        return _SimpleITK.ScaleSkewVersor3DTransform_GetCenter(self)

    def SetRotation(self, *args):
        r"""
        SetRotation(ScaleSkewVersor3DTransform self, VectorDouble versor)
        SetRotation(ScaleSkewVersor3DTransform self, VectorDouble axis, double angle)
        """
        return _SimpleITK.ScaleSkewVersor3DTransform_SetRotation(self, *args)

    def GetVersor(self):
        r"""GetVersor(ScaleSkewVersor3DTransform self) -> VectorDouble"""
        return _SimpleITK.ScaleSkewVersor3DTransform_GetVersor(self)

    def GetTranslation(self):
        r"""GetTranslation(ScaleSkewVersor3DTransform self) -> VectorDouble"""
        return _SimpleITK.ScaleSkewVersor3DTransform_GetTranslation(self)

    def SetTranslation(self, translation):
        r"""SetTranslation(ScaleSkewVersor3DTransform self, VectorDouble translation)"""
        return _SimpleITK.ScaleSkewVersor3DTransform_SetTranslation(self, translation)

    def GetScale(self):
        r"""GetScale(ScaleSkewVersor3DTransform self) -> VectorDouble"""
        return _SimpleITK.ScaleSkewVersor3DTransform_GetScale(self)

    def SetScale(self, scale):
        r"""SetScale(ScaleSkewVersor3DTransform self, VectorDouble scale)"""
        return _SimpleITK.ScaleSkewVersor3DTransform_SetScale(self, scale)

    def GetSkew(self):
        r"""GetSkew(ScaleSkewVersor3DTransform self) -> VectorDouble"""
        return _SimpleITK.ScaleSkewVersor3DTransform_GetSkew(self)

    def SetSkew(self, skew):
        r"""SetSkew(ScaleSkewVersor3DTransform self, VectorDouble skew)"""
        return _SimpleITK.ScaleSkewVersor3DTransform_SetSkew(self, skew)

    def Translate(self, offset):
        r"""Translate(ScaleSkewVersor3DTransform self, VectorDouble offset)"""
        return _SimpleITK.ScaleSkewVersor3DTransform_Translate(self, offset)

    def GetMatrix(self):
        r"""GetMatrix(ScaleSkewVersor3DTransform self) -> VectorDouble"""
        return _SimpleITK.ScaleSkewVersor3DTransform_GetMatrix(self)

# Register ScaleSkewVersor3DTransform in _SimpleITK:
_SimpleITK.ScaleSkewVersor3DTransform_swigregister(ScaleSkewVersor3DTransform)
class ComposeScaleSkewVersor3DTransform(Transform):
    r"""Proxy of C++ slicer_itk::simple::ComposeScaleSkewVersor3DTransform class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ComposeScaleSkewVersor3DTransform

    def __init__(self, *args):
        r"""
        __init__(ComposeScaleSkewVersor3DTransform self) -> ComposeScaleSkewVersor3DTransform
        __init__(ComposeScaleSkewVersor3DTransform self, ComposeScaleSkewVersor3DTransform arg2) -> ComposeScaleSkewVersor3DTransform
        __init__(ComposeScaleSkewVersor3DTransform self, Transform arg2) -> ComposeScaleSkewVersor3DTransform
        __init__(ComposeScaleSkewVersor3DTransform self, VectorDouble scale, VectorDouble skew, VectorDouble versor, VectorDouble translation=std::vector< double >(3, 0.0), VectorDouble fixedCenter=std::vector< double >(3, 0.0)) -> ComposeScaleSkewVersor3DTransform
        __init__(ComposeScaleSkewVersor3DTransform self, VectorDouble scale, VectorDouble skew, VectorDouble axis, double angle, VectorDouble translation=std::vector< double >(3, 0.0), VectorDouble fixedCenter=std::vector< double >(3, 0.0)) -> ComposeScaleSkewVersor3DTransform
        """
        _SimpleITK.ComposeScaleSkewVersor3DTransform_swiginit(self, _SimpleITK.new_ComposeScaleSkewVersor3DTransform(*args))

    def GetName(self):
        r"""GetName(ComposeScaleSkewVersor3DTransform self) -> std::string"""
        return _SimpleITK.ComposeScaleSkewVersor3DTransform_GetName(self)

    def SetCenter(self, params):
        r"""SetCenter(ComposeScaleSkewVersor3DTransform self, VectorDouble params)"""
        return _SimpleITK.ComposeScaleSkewVersor3DTransform_SetCenter(self, params)

    def GetCenter(self):
        r"""GetCenter(ComposeScaleSkewVersor3DTransform self) -> VectorDouble"""
        return _SimpleITK.ComposeScaleSkewVersor3DTransform_GetCenter(self)

    def SetRotation(self, *args):
        r"""
        SetRotation(ComposeScaleSkewVersor3DTransform self, VectorDouble versor)
        SetRotation(ComposeScaleSkewVersor3DTransform self, VectorDouble axis, double angle)
        """
        return _SimpleITK.ComposeScaleSkewVersor3DTransform_SetRotation(self, *args)

    def GetVersor(self):
        r"""GetVersor(ComposeScaleSkewVersor3DTransform self) -> VectorDouble"""
        return _SimpleITK.ComposeScaleSkewVersor3DTransform_GetVersor(self)

    def GetTranslation(self):
        r"""GetTranslation(ComposeScaleSkewVersor3DTransform self) -> VectorDouble"""
        return _SimpleITK.ComposeScaleSkewVersor3DTransform_GetTranslation(self)

    def SetTranslation(self, translation):
        r"""SetTranslation(ComposeScaleSkewVersor3DTransform self, VectorDouble translation)"""
        return _SimpleITK.ComposeScaleSkewVersor3DTransform_SetTranslation(self, translation)

    def GetScale(self):
        r"""GetScale(ComposeScaleSkewVersor3DTransform self) -> VectorDouble"""
        return _SimpleITK.ComposeScaleSkewVersor3DTransform_GetScale(self)

    def SetScale(self, scale):
        r"""SetScale(ComposeScaleSkewVersor3DTransform self, VectorDouble scale)"""
        return _SimpleITK.ComposeScaleSkewVersor3DTransform_SetScale(self, scale)

    def GetSkew(self):
        r"""GetSkew(ComposeScaleSkewVersor3DTransform self) -> VectorDouble"""
        return _SimpleITK.ComposeScaleSkewVersor3DTransform_GetSkew(self)

    def SetSkew(self, skew):
        r"""SetSkew(ComposeScaleSkewVersor3DTransform self, VectorDouble skew)"""
        return _SimpleITK.ComposeScaleSkewVersor3DTransform_SetSkew(self, skew)

    def Translate(self, offset):
        r"""Translate(ComposeScaleSkewVersor3DTransform self, VectorDouble offset)"""
        return _SimpleITK.ComposeScaleSkewVersor3DTransform_Translate(self, offset)

    def GetMatrix(self):
        r"""GetMatrix(ComposeScaleSkewVersor3DTransform self) -> VectorDouble"""
        return _SimpleITK.ComposeScaleSkewVersor3DTransform_GetMatrix(self)

# Register ComposeScaleSkewVersor3DTransform in _SimpleITK:
_SimpleITK.ComposeScaleSkewVersor3DTransform_swigregister(ComposeScaleSkewVersor3DTransform)
class ScaleVersor3DTransform(Transform):
    r"""Proxy of C++ slicer_itk::simple::ScaleVersor3DTransform class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ScaleVersor3DTransform

    def __init__(self, *args):
        r"""
        __init__(ScaleVersor3DTransform self) -> ScaleVersor3DTransform
        __init__(ScaleVersor3DTransform self, ScaleVersor3DTransform arg2) -> ScaleVersor3DTransform
        __init__(ScaleVersor3DTransform self, Transform arg2) -> ScaleVersor3DTransform
        __init__(ScaleVersor3DTransform self, VectorDouble scale, VectorDouble versor, VectorDouble translation=std::vector< double >(3, 0.0), VectorDouble fixedCenter=std::vector< double >(3, 0.0)) -> ScaleVersor3DTransform
        __init__(ScaleVersor3DTransform self, VectorDouble scale, VectorDouble axis, double angle, VectorDouble translation=std::vector< double >(3, 0.0), VectorDouble fixedCenter=std::vector< double >(3, 0.0)) -> ScaleVersor3DTransform
        """
        _SimpleITK.ScaleVersor3DTransform_swiginit(self, _SimpleITK.new_ScaleVersor3DTransform(*args))

    def GetName(self):
        r"""GetName(ScaleVersor3DTransform self) -> std::string"""
        return _SimpleITK.ScaleVersor3DTransform_GetName(self)

    def SetCenter(self, params):
        r"""SetCenter(ScaleVersor3DTransform self, VectorDouble params)"""
        return _SimpleITK.ScaleVersor3DTransform_SetCenter(self, params)

    def GetCenter(self):
        r"""GetCenter(ScaleVersor3DTransform self) -> VectorDouble"""
        return _SimpleITK.ScaleVersor3DTransform_GetCenter(self)

    def SetRotation(self, *args):
        r"""
        SetRotation(ScaleVersor3DTransform self, VectorDouble versor)
        SetRotation(ScaleVersor3DTransform self, VectorDouble axis, double angle)
        """
        return _SimpleITK.ScaleVersor3DTransform_SetRotation(self, *args)

    def GetVersor(self):
        r"""GetVersor(ScaleVersor3DTransform self) -> VectorDouble"""
        return _SimpleITK.ScaleVersor3DTransform_GetVersor(self)

    def GetTranslation(self):
        r"""GetTranslation(ScaleVersor3DTransform self) -> VectorDouble"""
        return _SimpleITK.ScaleVersor3DTransform_GetTranslation(self)

    def SetTranslation(self, translation):
        r"""SetTranslation(ScaleVersor3DTransform self, VectorDouble translation)"""
        return _SimpleITK.ScaleVersor3DTransform_SetTranslation(self, translation)

    def GetScale(self):
        r"""GetScale(ScaleVersor3DTransform self) -> VectorDouble"""
        return _SimpleITK.ScaleVersor3DTransform_GetScale(self)

    def SetScale(self, scale):
        r"""SetScale(ScaleVersor3DTransform self, VectorDouble scale)"""
        return _SimpleITK.ScaleVersor3DTransform_SetScale(self, scale)

    def Translate(self, offset):
        r"""Translate(ScaleVersor3DTransform self, VectorDouble offset)"""
        return _SimpleITK.ScaleVersor3DTransform_Translate(self, offset)

    def GetMatrix(self):
        r"""GetMatrix(ScaleVersor3DTransform self) -> VectorDouble"""
        return _SimpleITK.ScaleVersor3DTransform_GetMatrix(self)

# Register ScaleVersor3DTransform in _SimpleITK:
_SimpleITK.ScaleVersor3DTransform_swigregister(ScaleVersor3DTransform)
class Similarity2DTransform(Transform):
    r"""Proxy of C++ slicer_itk::simple::Similarity2DTransform class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_Similarity2DTransform

    def __init__(self, *args):
        r"""
        __init__(Similarity2DTransform self) -> Similarity2DTransform
        __init__(Similarity2DTransform self, double scaleFactor, double angle=0.0, VectorDouble translation=std::vector< double >(2, 0.0), VectorDouble fixedCenter=std::vector< double >(2, 0.0)) -> Similarity2DTransform
        __init__(Similarity2DTransform self, Similarity2DTransform arg2) -> Similarity2DTransform
        __init__(Similarity2DTransform self, Transform arg2) -> Similarity2DTransform
        """
        _SimpleITK.Similarity2DTransform_swiginit(self, _SimpleITK.new_Similarity2DTransform(*args))

    def GetName(self):
        r"""GetName(Similarity2DTransform self) -> std::string"""
        return _SimpleITK.Similarity2DTransform_GetName(self)

    def SetCenter(self, params):
        r"""SetCenter(Similarity2DTransform self, VectorDouble params)"""
        return _SimpleITK.Similarity2DTransform_SetCenter(self, params)

    def GetCenter(self):
        r"""GetCenter(Similarity2DTransform self) -> VectorDouble"""
        return _SimpleITK.Similarity2DTransform_GetCenter(self)

    def SetAngle(self, angle):
        r"""SetAngle(Similarity2DTransform self, double angle)"""
        return _SimpleITK.Similarity2DTransform_SetAngle(self, angle)

    def GetAngle(self):
        r"""GetAngle(Similarity2DTransform self) -> double"""
        return _SimpleITK.Similarity2DTransform_GetAngle(self)

    def GetTranslation(self):
        r"""GetTranslation(Similarity2DTransform self) -> VectorDouble"""
        return _SimpleITK.Similarity2DTransform_GetTranslation(self)

    def SetTranslation(self, translation):
        r"""SetTranslation(Similarity2DTransform self, VectorDouble translation)"""
        return _SimpleITK.Similarity2DTransform_SetTranslation(self, translation)

    def SetScale(self, scale):
        r"""SetScale(Similarity2DTransform self, double scale)"""
        return _SimpleITK.Similarity2DTransform_SetScale(self, scale)

    def GetScale(self):
        r"""GetScale(Similarity2DTransform self) -> double"""
        return _SimpleITK.Similarity2DTransform_GetScale(self)

    def GetMatrix(self):
        r"""GetMatrix(Similarity2DTransform self) -> VectorDouble"""
        return _SimpleITK.Similarity2DTransform_GetMatrix(self)

    def SetMatrix(self, matrix, tolerance=1e-10):
        r"""SetMatrix(Similarity2DTransform self, VectorDouble matrix, double tolerance=1e-10)"""
        return _SimpleITK.Similarity2DTransform_SetMatrix(self, matrix, tolerance)

# Register Similarity2DTransform in _SimpleITK:
_SimpleITK.Similarity2DTransform_swigregister(Similarity2DTransform)
class Similarity3DTransform(Transform):
    r"""Proxy of C++ slicer_itk::simple::Similarity3DTransform class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_Similarity3DTransform

    def __init__(self, *args):
        r"""
        __init__(Similarity3DTransform self) -> Similarity3DTransform
        __init__(Similarity3DTransform self, Similarity3DTransform arg2) -> Similarity3DTransform
        __init__(Similarity3DTransform self, Transform arg2) -> Similarity3DTransform
        __init__(Similarity3DTransform self, double scaleFactor, VectorDouble versor, VectorDouble translation=std::vector< double >(3, 0.0), VectorDouble fixedCenter=std::vector< double >(3, 0.0)) -> Similarity3DTransform
        __init__(Similarity3DTransform self, double scaleFactor, VectorDouble axis, double angle, VectorDouble translation=std::vector< double >(3, 0.0), VectorDouble fixedCenter=std::vector< double >(3, 0.0)) -> Similarity3DTransform
        """
        _SimpleITK.Similarity3DTransform_swiginit(self, _SimpleITK.new_Similarity3DTransform(*args))

    def GetName(self):
        r"""GetName(Similarity3DTransform self) -> std::string"""
        return _SimpleITK.Similarity3DTransform_GetName(self)

    def SetCenter(self, params):
        r"""SetCenter(Similarity3DTransform self, VectorDouble params)"""
        return _SimpleITK.Similarity3DTransform_SetCenter(self, params)

    def GetCenter(self):
        r"""GetCenter(Similarity3DTransform self) -> VectorDouble"""
        return _SimpleITK.Similarity3DTransform_GetCenter(self)

    def SetRotation(self, *args):
        r"""
        SetRotation(Similarity3DTransform self, VectorDouble versor)
        SetRotation(Similarity3DTransform self, VectorDouble axis, double angle)
        """
        return _SimpleITK.Similarity3DTransform_SetRotation(self, *args)

    def GetVersor(self):
        r"""GetVersor(Similarity3DTransform self) -> VectorDouble"""
        return _SimpleITK.Similarity3DTransform_GetVersor(self)

    def SetScale(self, scale):
        r"""SetScale(Similarity3DTransform self, double scale)"""
        return _SimpleITK.Similarity3DTransform_SetScale(self, scale)

    def GetScale(self):
        r"""GetScale(Similarity3DTransform self) -> double"""
        return _SimpleITK.Similarity3DTransform_GetScale(self)

    def GetTranslation(self):
        r"""GetTranslation(Similarity3DTransform self) -> VectorDouble"""
        return _SimpleITK.Similarity3DTransform_GetTranslation(self)

    def SetTranslation(self, translation):
        r"""SetTranslation(Similarity3DTransform self, VectorDouble translation)"""
        return _SimpleITK.Similarity3DTransform_SetTranslation(self, translation)

    def Translate(self, offset):
        r"""Translate(Similarity3DTransform self, VectorDouble offset)"""
        return _SimpleITK.Similarity3DTransform_Translate(self, offset)

    def GetMatrix(self):
        r"""GetMatrix(Similarity3DTransform self) -> VectorDouble"""
        return _SimpleITK.Similarity3DTransform_GetMatrix(self)

    def SetMatrix(self, matrix, tolerance=1e-10):
        r"""SetMatrix(Similarity3DTransform self, VectorDouble matrix, double tolerance=1e-10)"""
        return _SimpleITK.Similarity3DTransform_SetMatrix(self, matrix, tolerance)

# Register Similarity3DTransform in _SimpleITK:
_SimpleITK.Similarity3DTransform_swigregister(Similarity3DTransform)
class TranslationTransform(Transform):
    r"""Proxy of C++ slicer_itk::simple::TranslationTransform class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_TranslationTransform

    def __init__(self, *args):
        r"""
        __init__(TranslationTransform self, unsigned int dimensions, VectorDouble offset=std::vector< double >(3, 0.0)) -> TranslationTransform
        __init__(TranslationTransform self, TranslationTransform arg2) -> TranslationTransform
        __init__(TranslationTransform self, Transform arg2) -> TranslationTransform
        """
        _SimpleITK.TranslationTransform_swiginit(self, _SimpleITK.new_TranslationTransform(*args))

    def GetName(self):
        r"""GetName(TranslationTransform self) -> std::string"""
        return _SimpleITK.TranslationTransform_GetName(self)

    def SetOffset(self, params):
        r"""SetOffset(TranslationTransform self, VectorDouble params)"""
        return _SimpleITK.TranslationTransform_SetOffset(self, params)

    def GetOffset(self):
        r"""GetOffset(TranslationTransform self) -> VectorDouble"""
        return _SimpleITK.TranslationTransform_GetOffset(self)

# Register TranslationTransform in _SimpleITK:
_SimpleITK.TranslationTransform_swigregister(TranslationTransform)
class VersorTransform(Transform):
    r"""Proxy of C++ slicer_itk::simple::VersorTransform class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_VersorTransform

    def __init__(self, *args):
        r"""
        __init__(VersorTransform self) -> VersorTransform
        __init__(VersorTransform self, VersorTransform arg2) -> VersorTransform
        __init__(VersorTransform self, Transform arg2) -> VersorTransform
        __init__(VersorTransform self, VectorDouble versor, VectorDouble fixedCenter=std::vector< double >(3, 0.0)) -> VersorTransform
        __init__(VersorTransform self, VectorDouble axis, double angle, VectorDouble fixedCenter=std::vector< double >(3, 0.0)) -> VersorTransform
        """
        _SimpleITK.VersorTransform_swiginit(self, _SimpleITK.new_VersorTransform(*args))

    def GetName(self):
        r"""GetName(VersorTransform self) -> std::string"""
        return _SimpleITK.VersorTransform_GetName(self)

    def SetCenter(self, params):
        r"""SetCenter(VersorTransform self, VectorDouble params)"""
        return _SimpleITK.VersorTransform_SetCenter(self, params)

    def GetCenter(self):
        r"""GetCenter(VersorTransform self) -> VectorDouble"""
        return _SimpleITK.VersorTransform_GetCenter(self)

    def SetRotation(self, *args):
        r"""
        SetRotation(VersorTransform self, VectorDouble versor)
        SetRotation(VersorTransform self, VectorDouble axis, double angle)
        """
        return _SimpleITK.VersorTransform_SetRotation(self, *args)

    def GetVersor(self):
        r"""GetVersor(VersorTransform self) -> VectorDouble"""
        return _SimpleITK.VersorTransform_GetVersor(self)

    def GetMatrix(self):
        r"""GetMatrix(VersorTransform self) -> VectorDouble"""
        return _SimpleITK.VersorTransform_GetMatrix(self)

    def SetMatrix(self, matrix, tolerance=1e-10):
        r"""SetMatrix(VersorTransform self, VectorDouble matrix, double tolerance=1e-10)"""
        return _SimpleITK.VersorTransform_SetMatrix(self, matrix, tolerance)

# Register VersorTransform in _SimpleITK:
_SimpleITK.VersorTransform_swigregister(VersorTransform)
class VersorRigid3DTransform(Transform):
    r"""Proxy of C++ slicer_itk::simple::VersorRigid3DTransform class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_VersorRigid3DTransform

    def __init__(self, *args):
        r"""
        __init__(VersorRigid3DTransform self) -> VersorRigid3DTransform
        __init__(VersorRigid3DTransform self, VersorRigid3DTransform arg2) -> VersorRigid3DTransform
        __init__(VersorRigid3DTransform self, Transform arg2) -> VersorRigid3DTransform
        __init__(VersorRigid3DTransform self, VectorDouble versor, VectorDouble translation=std::vector< double >(3, 0.0), VectorDouble fixedCenter=std::vector< double >(3, 0.0)) -> VersorRigid3DTransform
        __init__(VersorRigid3DTransform self, VectorDouble axis, double angle, VectorDouble translation=std::vector< double >(3, 0.0), VectorDouble fixedCenter=std::vector< double >(3, 0.0)) -> VersorRigid3DTransform
        """
        _SimpleITK.VersorRigid3DTransform_swiginit(self, _SimpleITK.new_VersorRigid3DTransform(*args))

    def GetName(self):
        r"""GetName(VersorRigid3DTransform self) -> std::string"""
        return _SimpleITK.VersorRigid3DTransform_GetName(self)

    def SetCenter(self, params):
        r"""SetCenter(VersorRigid3DTransform self, VectorDouble params)"""
        return _SimpleITK.VersorRigid3DTransform_SetCenter(self, params)

    def GetCenter(self):
        r"""GetCenter(VersorRigid3DTransform self) -> VectorDouble"""
        return _SimpleITK.VersorRigid3DTransform_GetCenter(self)

    def SetRotation(self, *args):
        r"""
        SetRotation(VersorRigid3DTransform self, VectorDouble versor)
        SetRotation(VersorRigid3DTransform self, VectorDouble axis, double angle)
        """
        return _SimpleITK.VersorRigid3DTransform_SetRotation(self, *args)

    def GetVersor(self):
        r"""GetVersor(VersorRigid3DTransform self) -> VectorDouble"""
        return _SimpleITK.VersorRigid3DTransform_GetVersor(self)

    def GetTranslation(self):
        r"""GetTranslation(VersorRigid3DTransform self) -> VectorDouble"""
        return _SimpleITK.VersorRigid3DTransform_GetTranslation(self)

    def SetTranslation(self, translation):
        r"""SetTranslation(VersorRigid3DTransform self, VectorDouble translation)"""
        return _SimpleITK.VersorRigid3DTransform_SetTranslation(self, translation)

    def Translate(self, offset):
        r"""Translate(VersorRigid3DTransform self, VectorDouble offset)"""
        return _SimpleITK.VersorRigid3DTransform_Translate(self, offset)

    def GetMatrix(self):
        r"""GetMatrix(VersorRigid3DTransform self) -> VectorDouble"""
        return _SimpleITK.VersorRigid3DTransform_GetMatrix(self)

    def SetMatrix(self, matrix, tolerance=1e-10):
        r"""SetMatrix(VersorRigid3DTransform self, VectorDouble matrix, double tolerance=1e-10)"""
        return _SimpleITK.VersorRigid3DTransform_SetMatrix(self, matrix, tolerance)

# Register VersorRigid3DTransform in _SimpleITK:
_SimpleITK.VersorRigid3DTransform_swigregister(VersorRigid3DTransform)
class CompositeTransform(Transform):
    r"""Proxy of C++ slicer_itk::simple::CompositeTransform class."""

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

    def __init__(self, *args):
        r"""
        __init__(CompositeTransform self, unsigned int dimensions) -> CompositeTransform
        __init__(CompositeTransform self, Transform arg2) -> CompositeTransform
        __init__(CompositeTransform self, CompositeTransform arg2) -> CompositeTransform
        __init__(CompositeTransform self, VectorOfTransform arg2) -> CompositeTransform
        """
        _SimpleITK.CompositeTransform_swiginit(self, _SimpleITK.new_CompositeTransform(*args))
    __swig_destroy__ = _SimpleITK.delete_CompositeTransform

    def GetName(self):
        r"""GetName(CompositeTransform self) -> std::string"""
        return _SimpleITK.CompositeTransform_GetName(self)

    def FlattenTransform(self):
        r"""FlattenTransform(CompositeTransform self)"""
        return _SimpleITK.CompositeTransform_FlattenTransform(self)

    def AddTransform(self, t):
        r"""AddTransform(CompositeTransform self, Transform t)"""
        return _SimpleITK.CompositeTransform_AddTransform(self, t)

    def GetNumberOfTransforms(self):
        r"""GetNumberOfTransforms(CompositeTransform self) -> unsigned int"""
        return _SimpleITK.CompositeTransform_GetNumberOfTransforms(self)

    def ClearTransforms(self):
        r"""ClearTransforms(CompositeTransform self)"""
        return _SimpleITK.CompositeTransform_ClearTransforms(self)

    def RemoveTransform(self):
        r"""RemoveTransform(CompositeTransform self)"""
        return _SimpleITK.CompositeTransform_RemoveTransform(self)

    def GetBackTransform(self):
        r"""GetBackTransform(CompositeTransform self) -> Transform"""
        val = _SimpleITK.CompositeTransform_GetBackTransform(self)

        val = val.Downcast()


        return val


    def GetNthTransform(self, n):
        r"""GetNthTransform(CompositeTransform self, unsigned int n) -> Transform"""
        val = _SimpleITK.CompositeTransform_GetNthTransform(self, n)

        val = val.Downcast()


        return val


# Register CompositeTransform in _SimpleITK:
_SimpleITK.CompositeTransform_swigregister(CompositeTransform)
class ProcessObject(object):
    r"""Proxy of C++ slicer_itk::simple::ProcessObject class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ProcessObject

    def __str__(self):
        r"""__str__(ProcessObject self) -> std::string"""
        return _SimpleITK.ProcessObject___str__(self)

    def GetName(self):
        r"""GetName(ProcessObject self) -> std::string"""
        return _SimpleITK.ProcessObject_GetName(self)

    def DebugOn(self):
        r"""DebugOn(ProcessObject self)"""
        return _SimpleITK.ProcessObject_DebugOn(self)

    def DebugOff(self):
        r"""DebugOff(ProcessObject self)"""
        return _SimpleITK.ProcessObject_DebugOff(self)

    def GetDebug(self):
        r"""GetDebug(ProcessObject self) -> bool"""
        return _SimpleITK.ProcessObject_GetDebug(self)

    def SetDebug(self, debugFlag):
        r"""SetDebug(ProcessObject self, bool debugFlag)"""
        return _SimpleITK.ProcessObject_SetDebug(self, debugFlag)

    @staticmethod
    def GlobalDefaultDebugOn():
        r"""GlobalDefaultDebugOn()"""
        return _SimpleITK.ProcessObject_GlobalDefaultDebugOn()

    @staticmethod
    def GlobalDefaultDebugOff():
        r"""GlobalDefaultDebugOff()"""
        return _SimpleITK.ProcessObject_GlobalDefaultDebugOff()

    @staticmethod
    def GetGlobalDefaultDebug():
        r"""GetGlobalDefaultDebug() -> bool"""
        return _SimpleITK.ProcessObject_GetGlobalDefaultDebug()

    @staticmethod
    def SetGlobalDefaultDebug(debugFlag):
        r"""SetGlobalDefaultDebug(bool debugFlag)"""
        return _SimpleITK.ProcessObject_SetGlobalDefaultDebug(debugFlag)

    @staticmethod
    def GlobalWarningDisplayOn():
        r"""GlobalWarningDisplayOn()"""
        return _SimpleITK.ProcessObject_GlobalWarningDisplayOn()

    @staticmethod
    def GlobalWarningDisplayOff():
        r"""GlobalWarningDisplayOff()"""
        return _SimpleITK.ProcessObject_GlobalWarningDisplayOff()

    @staticmethod
    def SetGlobalWarningDisplay(flag):
        r"""SetGlobalWarningDisplay(bool flag)"""
        return _SimpleITK.ProcessObject_SetGlobalWarningDisplay(flag)

    @staticmethod
    def GetGlobalWarningDisplay():
        r"""GetGlobalWarningDisplay() -> bool"""
        return _SimpleITK.ProcessObject_GetGlobalWarningDisplay()

    @staticmethod
    def GetGlobalDefaultCoordinateTolerance():
        r"""GetGlobalDefaultCoordinateTolerance() -> double"""
        return _SimpleITK.ProcessObject_GetGlobalDefaultCoordinateTolerance()

    @staticmethod
    def SetGlobalDefaultCoordinateTolerance(arg1):
        r"""SetGlobalDefaultCoordinateTolerance(double arg1)"""
        return _SimpleITK.ProcessObject_SetGlobalDefaultCoordinateTolerance(arg1)

    @staticmethod
    def GetGlobalDefaultDirectionTolerance():
        r"""GetGlobalDefaultDirectionTolerance() -> double"""
        return _SimpleITK.ProcessObject_GetGlobalDefaultDirectionTolerance()

    @staticmethod
    def SetGlobalDefaultDirectionTolerance(arg1):
        r"""SetGlobalDefaultDirectionTolerance(double arg1)"""
        return _SimpleITK.ProcessObject_SetGlobalDefaultDirectionTolerance(arg1)

    @staticmethod
    def SetGlobalDefaultThreader(threader):
        r"""SetGlobalDefaultThreader(std::string const & threader) -> bool"""
        return _SimpleITK.ProcessObject_SetGlobalDefaultThreader(threader)

    @staticmethod
    def GetGlobalDefaultThreader():
        r"""GetGlobalDefaultThreader() -> std::string"""
        return _SimpleITK.ProcessObject_GetGlobalDefaultThreader()

    @staticmethod
    def SetGlobalDefaultNumberOfThreads(n):
        r"""SetGlobalDefaultNumberOfThreads(unsigned int n)"""
        return _SimpleITK.ProcessObject_SetGlobalDefaultNumberOfThreads(n)

    @staticmethod
    def GetGlobalDefaultNumberOfThreads():
        r"""GetGlobalDefaultNumberOfThreads() -> unsigned int"""
        return _SimpleITK.ProcessObject_GetGlobalDefaultNumberOfThreads()

    def SetNumberOfThreads(self, n):
        r"""SetNumberOfThreads(ProcessObject self, unsigned int n)"""
        return _SimpleITK.ProcessObject_SetNumberOfThreads(self, n)

    def GetNumberOfThreads(self):
        r"""GetNumberOfThreads(ProcessObject self) -> unsigned int"""
        return _SimpleITK.ProcessObject_GetNumberOfThreads(self)

    def SetNumberOfWorkUnits(self, n):
        r"""SetNumberOfWorkUnits(ProcessObject self, unsigned int n)"""
        return _SimpleITK.ProcessObject_SetNumberOfWorkUnits(self, n)

    def GetNumberOfWorkUnits(self):
        r"""GetNumberOfWorkUnits(ProcessObject self) -> unsigned int"""
        return _SimpleITK.ProcessObject_GetNumberOfWorkUnits(self)

    def RemoveAllCommands(self):
        r"""RemoveAllCommands(ProcessObject self)"""
        return _SimpleITK.ProcessObject_RemoveAllCommands(self)

    def HasCommand(self, event):
        r"""HasCommand(ProcessObject self, slicer_itk::simple::EventEnum event) -> bool"""
        return _SimpleITK.ProcessObject_HasCommand(self, event)

    def GetProgress(self):
        r"""GetProgress(ProcessObject self) -> float"""
        return _SimpleITK.ProcessObject_GetProgress(self)

    def Abort(self):
        r"""Abort(ProcessObject self)"""
        return _SimpleITK.ProcessObject_Abort(self)

    def AddCommand(self, *args):
        r"""
        AddCommand(ProcessObject self, slicer_itk::simple::EventEnum event, Command cmd) -> int
        AddCommand(ProcessObject self, slicer_itk::simple::EventEnum e, PyObject * obj) -> int
        """
        return _SimpleITK.ProcessObject_AddCommand(self, *args)

# Register ProcessObject in _SimpleITK:
_SimpleITK.ProcessObject_swigregister(ProcessObject)

def ProcessObject_GlobalDefaultDebugOn():
    r"""ProcessObject_GlobalDefaultDebugOn()"""
    return _SimpleITK.ProcessObject_GlobalDefaultDebugOn()

def ProcessObject_GlobalDefaultDebugOff():
    r"""ProcessObject_GlobalDefaultDebugOff()"""
    return _SimpleITK.ProcessObject_GlobalDefaultDebugOff()

def ProcessObject_GetGlobalDefaultDebug():
    r"""ProcessObject_GetGlobalDefaultDebug() -> bool"""
    return _SimpleITK.ProcessObject_GetGlobalDefaultDebug()

def ProcessObject_SetGlobalDefaultDebug(debugFlag):
    r"""ProcessObject_SetGlobalDefaultDebug(bool debugFlag)"""
    return _SimpleITK.ProcessObject_SetGlobalDefaultDebug(debugFlag)

def ProcessObject_GlobalWarningDisplayOn():
    r"""ProcessObject_GlobalWarningDisplayOn()"""
    return _SimpleITK.ProcessObject_GlobalWarningDisplayOn()

def ProcessObject_GlobalWarningDisplayOff():
    r"""ProcessObject_GlobalWarningDisplayOff()"""
    return _SimpleITK.ProcessObject_GlobalWarningDisplayOff()

def ProcessObject_SetGlobalWarningDisplay(flag):
    r"""ProcessObject_SetGlobalWarningDisplay(bool flag)"""
    return _SimpleITK.ProcessObject_SetGlobalWarningDisplay(flag)

def ProcessObject_GetGlobalWarningDisplay():
    r"""ProcessObject_GetGlobalWarningDisplay() -> bool"""
    return _SimpleITK.ProcessObject_GetGlobalWarningDisplay()

def ProcessObject_GetGlobalDefaultCoordinateTolerance():
    r"""ProcessObject_GetGlobalDefaultCoordinateTolerance() -> double"""
    return _SimpleITK.ProcessObject_GetGlobalDefaultCoordinateTolerance()

def ProcessObject_SetGlobalDefaultCoordinateTolerance(arg1):
    r"""ProcessObject_SetGlobalDefaultCoordinateTolerance(double arg1)"""
    return _SimpleITK.ProcessObject_SetGlobalDefaultCoordinateTolerance(arg1)

def ProcessObject_GetGlobalDefaultDirectionTolerance():
    r"""ProcessObject_GetGlobalDefaultDirectionTolerance() -> double"""
    return _SimpleITK.ProcessObject_GetGlobalDefaultDirectionTolerance()

def ProcessObject_SetGlobalDefaultDirectionTolerance(arg1):
    r"""ProcessObject_SetGlobalDefaultDirectionTolerance(double arg1)"""
    return _SimpleITK.ProcessObject_SetGlobalDefaultDirectionTolerance(arg1)

def ProcessObject_SetGlobalDefaultThreader(threader):
    r"""ProcessObject_SetGlobalDefaultThreader(std::string const & threader) -> bool"""
    return _SimpleITK.ProcessObject_SetGlobalDefaultThreader(threader)

def ProcessObject_GetGlobalDefaultThreader():
    r"""ProcessObject_GetGlobalDefaultThreader() -> std::string"""
    return _SimpleITK.ProcessObject_GetGlobalDefaultThreader()

def ProcessObject_SetGlobalDefaultNumberOfThreads(n):
    r"""ProcessObject_SetGlobalDefaultNumberOfThreads(unsigned int n)"""
    return _SimpleITK.ProcessObject_SetGlobalDefaultNumberOfThreads(n)

def ProcessObject_GetGlobalDefaultNumberOfThreads():
    r"""ProcessObject_GetGlobalDefaultNumberOfThreads() -> unsigned int"""
    return _SimpleITK.ProcessObject_GetGlobalDefaultNumberOfThreads()

class ImageFilter(ProcessObject):
    r"""Proxy of C++ slicer_itk::simple::ImageFilter class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ImageFilter

# Register ImageFilter in _SimpleITK:
_SimpleITK.ImageFilter_swigregister(ImageFilter)

def Show(*args, **kwargs):
    r"""Show(Image image, std::string const & title="", bool const debugOn=slicer_itk::simple::ProcessObject::GetGlobalDefaultDebug())"""
    return _SimpleITK.Show(*args, **kwargs)
class ImageFileWriter(ProcessObject):
    r"""Proxy of C++ slicer_itk::simple::ImageFileWriter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ImageFileWriter

    def __init__(self):
        r"""__init__(ImageFileWriter self) -> ImageFileWriter"""
        _SimpleITK.ImageFileWriter_swiginit(self, _SimpleITK.new_ImageFileWriter())

    def __str__(self):
        r"""__str__(ImageFileWriter self) -> std::string"""
        return _SimpleITK.ImageFileWriter___str__(self)

    def GetName(self):
        r"""GetName(ImageFileWriter self) -> std::string"""
        return _SimpleITK.ImageFileWriter_GetName(self)

    def GetRegisteredImageIOs(self):
        r"""GetRegisteredImageIOs(ImageFileWriter self) -> VectorString"""
        return _SimpleITK.ImageFileWriter_GetRegisteredImageIOs(self)

    def SetUseCompression(self, UseCompression):
        r"""SetUseCompression(ImageFileWriter self, bool UseCompression)"""
        return _SimpleITK.ImageFileWriter_SetUseCompression(self, UseCompression)

    def GetUseCompression(self):
        r"""GetUseCompression(ImageFileWriter self) -> bool"""
        return _SimpleITK.ImageFileWriter_GetUseCompression(self)

    def UseCompressionOn(self):
        r"""UseCompressionOn(ImageFileWriter self)"""
        return _SimpleITK.ImageFileWriter_UseCompressionOn(self)

    def UseCompressionOff(self):
        r"""UseCompressionOff(ImageFileWriter self)"""
        return _SimpleITK.ImageFileWriter_UseCompressionOff(self)

    def SetCompressionLevel(self, arg2):
        r"""SetCompressionLevel(ImageFileWriter self, int arg2)"""
        return _SimpleITK.ImageFileWriter_SetCompressionLevel(self, arg2)

    def GetCompressionLevel(self):
        r"""GetCompressionLevel(ImageFileWriter self) -> int"""
        return _SimpleITK.ImageFileWriter_GetCompressionLevel(self)

    def SetCompressor(self, arg2):
        r"""SetCompressor(ImageFileWriter self, std::string const & arg2)"""
        return _SimpleITK.ImageFileWriter_SetCompressor(self, arg2)

    def GetCompressor(self):
        r"""GetCompressor(ImageFileWriter self) -> std::string"""
        return _SimpleITK.ImageFileWriter_GetCompressor(self)

    def SetImageIO(self, imageio):
        r"""SetImageIO(ImageFileWriter self, std::string const & imageio)"""
        return _SimpleITK.ImageFileWriter_SetImageIO(self, imageio)

    def GetImageIO(self):
        r"""GetImageIO(ImageFileWriter self) -> std::string"""
        return _SimpleITK.ImageFileWriter_GetImageIO(self)

    def SetKeepOriginalImageUID(self, KeepOriginalImageUID):
        r"""SetKeepOriginalImageUID(ImageFileWriter self, bool KeepOriginalImageUID)"""
        return _SimpleITK.ImageFileWriter_SetKeepOriginalImageUID(self, KeepOriginalImageUID)

    def GetKeepOriginalImageUID(self):
        r"""GetKeepOriginalImageUID(ImageFileWriter self) -> bool"""
        return _SimpleITK.ImageFileWriter_GetKeepOriginalImageUID(self)

    def KeepOriginalImageUIDOn(self):
        r"""KeepOriginalImageUIDOn(ImageFileWriter self)"""
        return _SimpleITK.ImageFileWriter_KeepOriginalImageUIDOn(self)

    def KeepOriginalImageUIDOff(self):
        r"""KeepOriginalImageUIDOff(ImageFileWriter self)"""
        return _SimpleITK.ImageFileWriter_KeepOriginalImageUIDOff(self)

    def SetFileName(self, fileName):
        r"""SetFileName(ImageFileWriter self, slicer_itk::simple::PathType const & fileName)"""
        return _SimpleITK.ImageFileWriter_SetFileName(self, fileName)

    def GetFileName(self):
        r"""GetFileName(ImageFileWriter self) -> slicer_itk::simple::PathType"""
        return _SimpleITK.ImageFileWriter_GetFileName(self)

    def Execute(self, *args):
        r"""
        Execute(ImageFileWriter self, Image arg2)
        Execute(ImageFileWriter self, Image arg2, slicer_itk::simple::PathType const & inFileName, bool useCompression, int compressionLevel)
        """
        return _SimpleITK.ImageFileWriter_Execute(self, *args)

# Register ImageFileWriter in _SimpleITK:
_SimpleITK.ImageFileWriter_swigregister(ImageFileWriter)
class ImageSeriesWriter(ProcessObject):
    r"""Proxy of C++ slicer_itk::simple::ImageSeriesWriter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ImageSeriesWriter

    def __init__(self):
        r"""__init__(ImageSeriesWriter self) -> ImageSeriesWriter"""
        _SimpleITK.ImageSeriesWriter_swiginit(self, _SimpleITK.new_ImageSeriesWriter())

    def __str__(self):
        r"""__str__(ImageSeriesWriter self) -> std::string"""
        return _SimpleITK.ImageSeriesWriter___str__(self)

    def GetRegisteredImageIOs(self):
        r"""GetRegisteredImageIOs(ImageSeriesWriter self) -> VectorString"""
        return _SimpleITK.ImageSeriesWriter_GetRegisteredImageIOs(self)

    def SetImageIO(self, imageio):
        r"""SetImageIO(ImageSeriesWriter self, std::string const & imageio)"""
        return _SimpleITK.ImageSeriesWriter_SetImageIO(self, imageio)

    def GetImageIO(self):
        r"""GetImageIO(ImageSeriesWriter self) -> std::string"""
        return _SimpleITK.ImageSeriesWriter_GetImageIO(self)

    def GetName(self):
        r"""GetName(ImageSeriesWriter self) -> std::string"""
        return _SimpleITK.ImageSeriesWriter_GetName(self)

    def SetUseCompression(self, UseCompression):
        r"""SetUseCompression(ImageSeriesWriter self, bool UseCompression)"""
        return _SimpleITK.ImageSeriesWriter_SetUseCompression(self, UseCompression)

    def GetUseCompression(self):
        r"""GetUseCompression(ImageSeriesWriter self) -> bool"""
        return _SimpleITK.ImageSeriesWriter_GetUseCompression(self)

    def UseCompressionOn(self):
        r"""UseCompressionOn(ImageSeriesWriter self)"""
        return _SimpleITK.ImageSeriesWriter_UseCompressionOn(self)

    def UseCompressionOff(self):
        r"""UseCompressionOff(ImageSeriesWriter self)"""
        return _SimpleITK.ImageSeriesWriter_UseCompressionOff(self)

    def SetCompressionLevel(self, arg2):
        r"""SetCompressionLevel(ImageSeriesWriter self, int arg2)"""
        return _SimpleITK.ImageSeriesWriter_SetCompressionLevel(self, arg2)

    def GetCompressionLevel(self):
        r"""GetCompressionLevel(ImageSeriesWriter self) -> int"""
        return _SimpleITK.ImageSeriesWriter_GetCompressionLevel(self)

    def SetCompressor(self, arg2):
        r"""SetCompressor(ImageSeriesWriter self, std::string const & arg2)"""
        return _SimpleITK.ImageSeriesWriter_SetCompressor(self, arg2)

    def GetCompressor(self):
        r"""GetCompressor(ImageSeriesWriter self) -> std::string"""
        return _SimpleITK.ImageSeriesWriter_GetCompressor(self)

    def SetFileNames(self, fileNames):
        r"""SetFileNames(ImageSeriesWriter self, VectorString fileNames)"""
        return _SimpleITK.ImageSeriesWriter_SetFileNames(self, fileNames)

    def GetFileNames(self):
        r"""GetFileNames(ImageSeriesWriter self) -> VectorString"""
        return _SimpleITK.ImageSeriesWriter_GetFileNames(self)

    def Execute(self, *args):
        r"""
        Execute(ImageSeriesWriter self, Image arg2)
        Execute(ImageSeriesWriter self, Image image, VectorString inFileNames, bool useCompression, int compressionLevel)
        """
        return _SimpleITK.ImageSeriesWriter_Execute(self, *args)

# Register ImageSeriesWriter in _SimpleITK:
_SimpleITK.ImageSeriesWriter_swigregister(ImageSeriesWriter)
class ImageReaderBase(ProcessObject):
    r"""Proxy of C++ slicer_itk::simple::ImageReaderBase class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ImageReaderBase

    def SetOutputPixelType(self, pixelID):
        r"""SetOutputPixelType(ImageReaderBase self, slicer_itk::simple::PixelIDValueEnum pixelID)"""
        return _SimpleITK.ImageReaderBase_SetOutputPixelType(self, pixelID)

    def GetOutputPixelType(self):
        r"""GetOutputPixelType(ImageReaderBase self) -> slicer_itk::simple::PixelIDValueEnum"""
        return _SimpleITK.ImageReaderBase_GetOutputPixelType(self)

    def Execute(self):
        r"""Execute(ImageReaderBase self) -> Image"""
        return _SimpleITK.ImageReaderBase_Execute(self)

    def __str__(self):
        r"""__str__(ImageReaderBase self) -> std::string"""
        return _SimpleITK.ImageReaderBase___str__(self)

    def GetRegisteredImageIOs(self):
        r"""GetRegisteredImageIOs(ImageReaderBase self) -> VectorString"""
        return _SimpleITK.ImageReaderBase_GetRegisteredImageIOs(self)

    def SetLoadPrivateTags(self, loadPrivateTags):
        r"""SetLoadPrivateTags(ImageReaderBase self, bool loadPrivateTags)"""
        return _SimpleITK.ImageReaderBase_SetLoadPrivateTags(self, loadPrivateTags)

    def GetLoadPrivateTags(self):
        r"""GetLoadPrivateTags(ImageReaderBase self) -> bool"""
        return _SimpleITK.ImageReaderBase_GetLoadPrivateTags(self)

    def LoadPrivateTagsOn(self):
        r"""LoadPrivateTagsOn(ImageReaderBase self)"""
        return _SimpleITK.ImageReaderBase_LoadPrivateTagsOn(self)

    def LoadPrivateTagsOff(self):
        r"""LoadPrivateTagsOff(ImageReaderBase self)"""
        return _SimpleITK.ImageReaderBase_LoadPrivateTagsOff(self)

    def SetImageIO(self, imageio):
        r"""SetImageIO(ImageReaderBase self, std::string const & imageio)"""
        return _SimpleITK.ImageReaderBase_SetImageIO(self, imageio)

    def GetImageIO(self):
        r"""GetImageIO(ImageReaderBase self) -> std::string"""
        return _SimpleITK.ImageReaderBase_GetImageIO(self)

    @staticmethod
    def GetImageIOFromFileName(fileName):
        r"""GetImageIOFromFileName(slicer_itk::simple::PathType const & fileName) -> std::string"""
        return _SimpleITK.ImageReaderBase_GetImageIOFromFileName(fileName)

# Register ImageReaderBase in _SimpleITK:
_SimpleITK.ImageReaderBase_swigregister(ImageReaderBase)

def ImageReaderBase_GetImageIOFromFileName(fileName):
    r"""ImageReaderBase_GetImageIOFromFileName(slicer_itk::simple::PathType const & fileName) -> std::string"""
    return _SimpleITK.ImageReaderBase_GetImageIOFromFileName(fileName)

class ImageSeriesReader(ImageReaderBase):
    r"""Proxy of C++ slicer_itk::simple::ImageSeriesReader class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ImageSeriesReader

    def __init__(self):
        r"""__init__(ImageSeriesReader self) -> ImageSeriesReader"""
        _SimpleITK.ImageSeriesReader_swiginit(self, _SimpleITK.new_ImageSeriesReader())

    def __str__(self):
        r"""__str__(ImageSeriesReader self) -> std::string"""
        return _SimpleITK.ImageSeriesReader___str__(self)

    def GetName(self):
        r"""GetName(ImageSeriesReader self) -> std::string"""
        return _SimpleITK.ImageSeriesReader_GetName(self)

    def SetMetaDataDictionaryArrayUpdate(self, metaDataDictionaryArrayUpdate):
        r"""SetMetaDataDictionaryArrayUpdate(ImageSeriesReader self, bool metaDataDictionaryArrayUpdate)"""
        return _SimpleITK.ImageSeriesReader_SetMetaDataDictionaryArrayUpdate(self, metaDataDictionaryArrayUpdate)

    def GetMetaDataDictionaryArrayUpdate(self):
        r"""GetMetaDataDictionaryArrayUpdate(ImageSeriesReader self) -> bool"""
        return _SimpleITK.ImageSeriesReader_GetMetaDataDictionaryArrayUpdate(self)

    def MetaDataDictionaryArrayUpdateOn(self):
        r"""MetaDataDictionaryArrayUpdateOn(ImageSeriesReader self)"""
        return _SimpleITK.ImageSeriesReader_MetaDataDictionaryArrayUpdateOn(self)

    def MetaDataDictionaryArrayUpdateOff(self):
        r"""MetaDataDictionaryArrayUpdateOff(ImageSeriesReader self)"""
        return _SimpleITK.ImageSeriesReader_MetaDataDictionaryArrayUpdateOff(self)

    @staticmethod
    def GetGDCMSeriesFileNames(*args, **kwargs):
        r"""GetGDCMSeriesFileNames(slicer_itk::simple::PathType const & directory, std::string const & seriesID="", bool useSeriesDetails=False, bool recursive=False, bool loadSequences=False) -> VectorString"""
        return _SimpleITK.ImageSeriesReader_GetGDCMSeriesFileNames(*args, **kwargs)

    @staticmethod
    def GetGDCMSeriesIDs(directory, useSeriesDetails=False):
        r"""GetGDCMSeriesIDs(slicer_itk::simple::PathType const & directory, bool useSeriesDetails=False) -> VectorString"""
        return _SimpleITK.ImageSeriesReader_GetGDCMSeriesIDs(directory, useSeriesDetails)

    def SetFileNames(self, fileNames):
        r"""SetFileNames(ImageSeriesReader self, VectorString fileNames)"""
        return _SimpleITK.ImageSeriesReader_SetFileNames(self, fileNames)

    def GetFileNames(self):
        r"""GetFileNames(ImageSeriesReader self) -> VectorString"""
        return _SimpleITK.ImageSeriesReader_GetFileNames(self)

    def SetSpacingWarningRelThreshold(self, spacingWarningRelThreshold):
        r"""SetSpacingWarningRelThreshold(ImageSeriesReader self, double spacingWarningRelThreshold)"""
        return _SimpleITK.ImageSeriesReader_SetSpacingWarningRelThreshold(self, spacingWarningRelThreshold)

    def GetSpacingWarningRelThreshold(self):
        r"""GetSpacingWarningRelThreshold(ImageSeriesReader self) -> double"""
        return _SimpleITK.ImageSeriesReader_GetSpacingWarningRelThreshold(self)

    def SetForceOrthogonalDirection(self, forceOrthogonalDirection):
        r"""SetForceOrthogonalDirection(ImageSeriesReader self, bool forceOrthogonalDirection)"""
        return _SimpleITK.ImageSeriesReader_SetForceOrthogonalDirection(self, forceOrthogonalDirection)

    def GetForceOrthogonalDirection(self):
        r"""GetForceOrthogonalDirection(ImageSeriesReader self) -> bool"""
        return _SimpleITK.ImageSeriesReader_GetForceOrthogonalDirection(self)

    def ForceOrthogonalDirectionOn(self):
        r"""ForceOrthogonalDirectionOn(ImageSeriesReader self)"""
        return _SimpleITK.ImageSeriesReader_ForceOrthogonalDirectionOn(self)

    def ForceOrthogonalDirectionOff(self):
        r"""ForceOrthogonalDirectionOff(ImageSeriesReader self)"""
        return _SimpleITK.ImageSeriesReader_ForceOrthogonalDirectionOff(self)

    def SetReverseOrder(self, reverseOrder):
        r"""SetReverseOrder(ImageSeriesReader self, bool reverseOrder)"""
        return _SimpleITK.ImageSeriesReader_SetReverseOrder(self, reverseOrder)

    def GetReverseOrder(self):
        r"""GetReverseOrder(ImageSeriesReader self) -> bool"""
        return _SimpleITK.ImageSeriesReader_GetReverseOrder(self)

    def ReverseOrderOn(self):
        r"""ReverseOrderOn(ImageSeriesReader self)"""
        return _SimpleITK.ImageSeriesReader_ReverseOrderOn(self)

    def ReverseOrderOff(self):
        r"""ReverseOrderOff(ImageSeriesReader self)"""
        return _SimpleITK.ImageSeriesReader_ReverseOrderOff(self)

    def Execute(self):
        r"""Execute(ImageSeriesReader self) -> Image"""
        return _SimpleITK.ImageSeriesReader_Execute(self)

    def GetMetaDataKeys(self, slice):
        r"""GetMetaDataKeys(ImageSeriesReader self, unsigned int slice) -> VectorString"""
        return _SimpleITK.ImageSeriesReader_GetMetaDataKeys(self, slice)

    def HasMetaDataKey(self, slice, key):
        r"""HasMetaDataKey(ImageSeriesReader self, unsigned int slice, std::string const & key) -> bool"""
        return _SimpleITK.ImageSeriesReader_HasMetaDataKey(self, slice, key)

    def GetMetaData(self, slice, key):
        r"""GetMetaData(ImageSeriesReader self, unsigned int slice, std::string const & key) -> std::string"""
        return _SimpleITK.ImageSeriesReader_GetMetaData(self, slice, key)

# Register ImageSeriesReader in _SimpleITK:
_SimpleITK.ImageSeriesReader_swigregister(ImageSeriesReader)

def ImageSeriesReader_GetGDCMSeriesFileNames(*args, **kwargs):
    r"""ImageSeriesReader_GetGDCMSeriesFileNames(slicer_itk::simple::PathType const & directory, std::string const & seriesID="", bool useSeriesDetails=False, bool recursive=False, bool loadSequences=False) -> VectorString"""
    return _SimpleITK.ImageSeriesReader_GetGDCMSeriesFileNames(*args, **kwargs)

def ImageSeriesReader_GetGDCMSeriesIDs(directory, useSeriesDetails=False):
    r"""ImageSeriesReader_GetGDCMSeriesIDs(slicer_itk::simple::PathType const & directory, bool useSeriesDetails=False) -> VectorString"""
    return _SimpleITK.ImageSeriesReader_GetGDCMSeriesIDs(directory, useSeriesDetails)

class ImageFileReader(ImageReaderBase):
    r"""Proxy of C++ slicer_itk::simple::ImageFileReader class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ImageFileReader

    def __init__(self):
        r"""__init__(ImageFileReader self) -> ImageFileReader"""
        _SimpleITK.ImageFileReader_swiginit(self, _SimpleITK.new_ImageFileReader())

    def __str__(self):
        r"""__str__(ImageFileReader self) -> std::string"""
        return _SimpleITK.ImageFileReader___str__(self)

    def GetName(self):
        r"""GetName(ImageFileReader self) -> std::string"""
        return _SimpleITK.ImageFileReader_GetName(self)

    def SetFileName(self, fn):
        r"""SetFileName(ImageFileReader self, slicer_itk::simple::PathType const & fn)"""
        return _SimpleITK.ImageFileReader_SetFileName(self, fn)

    def GetFileName(self):
        r"""GetFileName(ImageFileReader self) -> slicer_itk::simple::PathType"""
        return _SimpleITK.ImageFileReader_GetFileName(self)

    def Execute(self):
        r"""Execute(ImageFileReader self) -> Image"""
        return _SimpleITK.ImageFileReader_Execute(self)

    def ReadImageInformation(self):
        r"""ReadImageInformation(ImageFileReader self)"""
        return _SimpleITK.ImageFileReader_ReadImageInformation(self)

    def GetPixelID(self):
        r"""GetPixelID(ImageFileReader self) -> slicer_itk::simple::PixelIDValueEnum"""
        return _SimpleITK.ImageFileReader_GetPixelID(self)

    def GetPixelIDValue(self):
        r"""GetPixelIDValue(ImageFileReader self) -> slicer_itk::simple::PixelIDValueType"""
        return _SimpleITK.ImageFileReader_GetPixelIDValue(self)

    def GetDimension(self):
        r"""GetDimension(ImageFileReader self) -> unsigned int"""
        return _SimpleITK.ImageFileReader_GetDimension(self)

    def GetNumberOfComponents(self):
        r"""GetNumberOfComponents(ImageFileReader self) -> unsigned int"""
        return _SimpleITK.ImageFileReader_GetNumberOfComponents(self)

    def GetOrigin(self):
        r"""GetOrigin(ImageFileReader self) -> VectorDouble"""
        return _SimpleITK.ImageFileReader_GetOrigin(self)

    def GetSpacing(self):
        r"""GetSpacing(ImageFileReader self) -> VectorDouble"""
        return _SimpleITK.ImageFileReader_GetSpacing(self)

    def GetDirection(self):
        r"""GetDirection(ImageFileReader self) -> VectorDouble"""
        return _SimpleITK.ImageFileReader_GetDirection(self)

    def GetSize(self):
        r"""GetSize(ImageFileReader self) -> VectorUInt64"""
        return _SimpleITK.ImageFileReader_GetSize(self)

    def GetMetaDataKeys(self):
        r"""GetMetaDataKeys(ImageFileReader self) -> VectorString"""
        return _SimpleITK.ImageFileReader_GetMetaDataKeys(self)

    def HasMetaDataKey(self, key):
        r"""HasMetaDataKey(ImageFileReader self, std::string const & key) -> bool"""
        return _SimpleITK.ImageFileReader_HasMetaDataKey(self, key)

    def GetMetaData(self, key):
        r"""GetMetaData(ImageFileReader self, std::string const & key) -> std::string"""
        return _SimpleITK.ImageFileReader_GetMetaData(self, key)

    def SetExtractSize(self, size):
        r"""SetExtractSize(ImageFileReader self, VectorUInt32 size)"""
        return _SimpleITK.ImageFileReader_SetExtractSize(self, size)

    def GetExtractSize(self):
        r"""GetExtractSize(ImageFileReader self) -> VectorUInt32"""
        return _SimpleITK.ImageFileReader_GetExtractSize(self)

    def SetExtractIndex(self, index):
        r"""SetExtractIndex(ImageFileReader self, VectorInt32 index)"""
        return _SimpleITK.ImageFileReader_SetExtractIndex(self, index)

    def GetExtractIndex(self):
        r"""GetExtractIndex(ImageFileReader self) -> VectorInt32"""
        return _SimpleITK.ImageFileReader_GetExtractIndex(self)

# Register ImageFileReader in _SimpleITK:
_SimpleITK.ImageFileReader_swigregister(ImageFileReader)
class ImageViewer(object):
    r"""Proxy of C++ slicer_itk::simple::ImageViewer class."""

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

    def __init__(self):
        r"""__init__(ImageViewer self) -> ImageViewer"""
        _SimpleITK.ImageViewer_swiginit(self, _SimpleITK.new_ImageViewer())

    def GetName(self):
        r"""GetName(ImageViewer self) -> std::string"""
        return _SimpleITK.ImageViewer_GetName(self)

    @staticmethod
    def SetGlobalDefaultSearchPath(path):
        r"""SetGlobalDefaultSearchPath(VectorString path)"""
        return _SimpleITK.ImageViewer_SetGlobalDefaultSearchPath(path)

    @staticmethod
    def GetGlobalDefaultSearchPath():
        r"""GetGlobalDefaultSearchPath() -> VectorString"""
        return _SimpleITK.ImageViewer_GetGlobalDefaultSearchPath()

    @staticmethod
    def SetGlobalDefaultExecutableNames(names):
        r"""SetGlobalDefaultExecutableNames(VectorString names)"""
        return _SimpleITK.ImageViewer_SetGlobalDefaultExecutableNames(names)

    @staticmethod
    def GetGlobalDefaultExecutableNames():
        r"""GetGlobalDefaultExecutableNames() -> VectorString"""
        return _SimpleITK.ImageViewer_GetGlobalDefaultExecutableNames()

    @staticmethod
    def SetGlobalDefaultFileExtension(ext):
        r"""SetGlobalDefaultFileExtension(std::string const & ext)"""
        return _SimpleITK.ImageViewer_SetGlobalDefaultFileExtension(ext)

    @staticmethod
    def GetGlobalDefaultFileExtension():
        r"""GetGlobalDefaultFileExtension() -> std::string const &"""
        return _SimpleITK.ImageViewer_GetGlobalDefaultFileExtension()

    @staticmethod
    def SetGlobalDefaultApplication(app):
        r"""SetGlobalDefaultApplication(slicer_itk::simple::PathType const & app)"""
        return _SimpleITK.ImageViewer_SetGlobalDefaultApplication(app)

    @staticmethod
    def GetGlobalDefaultApplication():
        r"""GetGlobalDefaultApplication() -> slicer_itk::simple::PathType const &"""
        return _SimpleITK.ImageViewer_GetGlobalDefaultApplication()

    def SetApplication(self, *args, **kwargs):
        r"""SetApplication(ImageViewer self, slicer_itk::simple::PathType const & app, std::string const & command="%a %f")"""
        return _SimpleITK.ImageViewer_SetApplication(self, *args, **kwargs)

    def GetApplication(self):
        r"""GetApplication(ImageViewer self) -> slicer_itk::simple::PathType const &"""
        return _SimpleITK.ImageViewer_GetApplication(self)

    def SetCommand(self, command):
        r"""SetCommand(ImageViewer self, std::string const & command)"""
        return _SimpleITK.ImageViewer_SetCommand(self, command)

    def GetCommand(self):
        r"""GetCommand(ImageViewer self) -> std::string const &"""
        return _SimpleITK.ImageViewer_GetCommand(self)

    def SetFileExtension(self, ext):
        r"""SetFileExtension(ImageViewer self, std::string const & ext)"""
        return _SimpleITK.ImageViewer_SetFileExtension(self, ext)

    def GetFileExtension(self):
        r"""GetFileExtension(ImageViewer self) -> std::string const &"""
        return _SimpleITK.ImageViewer_GetFileExtension(self)

    @staticmethod
    def SetGlobalDefaultDebug(dbg):
        r"""SetGlobalDefaultDebug(bool const dbg)"""
        return _SimpleITK.ImageViewer_SetGlobalDefaultDebug(dbg)

    @staticmethod
    def GetGlobalDefaultDebug():
        r"""GetGlobalDefaultDebug() -> bool"""
        return _SimpleITK.ImageViewer_GetGlobalDefaultDebug()

    @staticmethod
    def SetGlobalDefaultDebugOn():
        r"""SetGlobalDefaultDebugOn()"""
        return _SimpleITK.ImageViewer_SetGlobalDefaultDebugOn()

    @staticmethod
    def SetGlobalDefaultDebugOff():
        r"""SetGlobalDefaultDebugOff()"""
        return _SimpleITK.ImageViewer_SetGlobalDefaultDebugOff()

    @staticmethod
    def SetProcessDelay(delay):
        r"""SetProcessDelay(unsigned int const delay)"""
        return _SimpleITK.ImageViewer_SetProcessDelay(delay)

    @staticmethod
    def GetProcessDelay():
        r"""GetProcessDelay() -> unsigned int"""
        return _SimpleITK.ImageViewer_GetProcessDelay()

    def SetTitle(self, t):
        r"""SetTitle(ImageViewer self, std::string const & t)"""
        return _SimpleITK.ImageViewer_SetTitle(self, t)

    def GetTitle(self):
        r"""GetTitle(ImageViewer self) -> std::string const &"""
        return _SimpleITK.ImageViewer_GetTitle(self)

    def Execute(self, image):
        r"""Execute(ImageViewer self, Image image)"""
        return _SimpleITK.ImageViewer_Execute(self, image)

    def __str__(self):
        r"""__str__(ImageViewer self) -> std::string"""
        return _SimpleITK.ImageViewer___str__(self)
    __swig_destroy__ = _SimpleITK.delete_ImageViewer

# Register ImageViewer in _SimpleITK:
_SimpleITK.ImageViewer_swigregister(ImageViewer)

def ImageViewer_SetGlobalDefaultSearchPath(path):
    r"""ImageViewer_SetGlobalDefaultSearchPath(VectorString path)"""
    return _SimpleITK.ImageViewer_SetGlobalDefaultSearchPath(path)

def ImageViewer_GetGlobalDefaultSearchPath():
    r"""ImageViewer_GetGlobalDefaultSearchPath() -> VectorString"""
    return _SimpleITK.ImageViewer_GetGlobalDefaultSearchPath()

def ImageViewer_SetGlobalDefaultExecutableNames(names):
    r"""ImageViewer_SetGlobalDefaultExecutableNames(VectorString names)"""
    return _SimpleITK.ImageViewer_SetGlobalDefaultExecutableNames(names)

def ImageViewer_GetGlobalDefaultExecutableNames():
    r"""ImageViewer_GetGlobalDefaultExecutableNames() -> VectorString"""
    return _SimpleITK.ImageViewer_GetGlobalDefaultExecutableNames()

def ImageViewer_SetGlobalDefaultFileExtension(ext):
    r"""ImageViewer_SetGlobalDefaultFileExtension(std::string const & ext)"""
    return _SimpleITK.ImageViewer_SetGlobalDefaultFileExtension(ext)

def ImageViewer_GetGlobalDefaultFileExtension():
    r"""ImageViewer_GetGlobalDefaultFileExtension() -> std::string const &"""
    return _SimpleITK.ImageViewer_GetGlobalDefaultFileExtension()

def ImageViewer_SetGlobalDefaultApplication(app):
    r"""ImageViewer_SetGlobalDefaultApplication(slicer_itk::simple::PathType const & app)"""
    return _SimpleITK.ImageViewer_SetGlobalDefaultApplication(app)

def ImageViewer_GetGlobalDefaultApplication():
    r"""ImageViewer_GetGlobalDefaultApplication() -> slicer_itk::simple::PathType const &"""
    return _SimpleITK.ImageViewer_GetGlobalDefaultApplication()

def ImageViewer_SetGlobalDefaultDebug(dbg):
    r"""ImageViewer_SetGlobalDefaultDebug(bool const dbg)"""
    return _SimpleITK.ImageViewer_SetGlobalDefaultDebug(dbg)

def ImageViewer_GetGlobalDefaultDebug():
    r"""ImageViewer_GetGlobalDefaultDebug() -> bool"""
    return _SimpleITK.ImageViewer_GetGlobalDefaultDebug()

def ImageViewer_SetGlobalDefaultDebugOn():
    r"""ImageViewer_SetGlobalDefaultDebugOn()"""
    return _SimpleITK.ImageViewer_SetGlobalDefaultDebugOn()

def ImageViewer_SetGlobalDefaultDebugOff():
    r"""ImageViewer_SetGlobalDefaultDebugOff()"""
    return _SimpleITK.ImageViewer_SetGlobalDefaultDebugOff()

def ImageViewer_SetProcessDelay(delay):
    r"""ImageViewer_SetProcessDelay(unsigned int const delay)"""
    return _SimpleITK.ImageViewer_SetProcessDelay(delay)

def ImageViewer_GetProcessDelay():
    r"""ImageViewer_GetProcessDelay() -> unsigned int"""
    return _SimpleITK.ImageViewer_GetProcessDelay()

class HashImageFilter(ProcessObject):
    r"""Proxy of C++ slicer_itk::simple::HashImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_HashImageFilter

    def __init__(self):
        r"""__init__(HashImageFilter self) -> HashImageFilter"""
        _SimpleITK.HashImageFilter_swiginit(self, _SimpleITK.new_HashImageFilter())
    SHA1 = _SimpleITK.HashImageFilter_SHA1
    
    MD5 = _SimpleITK.HashImageFilter_MD5
    

    def SetHashFunction(self, hashFunction):
        r"""SetHashFunction(HashImageFilter self, slicer_itk::simple::HashImageFilter::HashFunction hashFunction)"""
        return _SimpleITK.HashImageFilter_SetHashFunction(self, hashFunction)

    def GetHashFunction(self):
        r"""GetHashFunction(HashImageFilter self) -> slicer_itk::simple::HashImageFilter::HashFunction"""
        return _SimpleITK.HashImageFilter_GetHashFunction(self)

    def GetName(self):
        r"""GetName(HashImageFilter self) -> std::string"""
        return _SimpleITK.HashImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(HashImageFilter self) -> std::string"""
        return _SimpleITK.HashImageFilter___str__(self)

    def Execute(self, arg2):
        r"""Execute(HashImageFilter self, Image arg2) -> std::string"""
        return _SimpleITK.HashImageFilter_Execute(self, arg2)

# Register HashImageFilter in _SimpleITK:
_SimpleITK.HashImageFilter_swigregister(HashImageFilter)

def Hash(*args, **kwargs):
    r"""Hash(Image image, slicer_itk::simple::HashImageFilter::HashFunction function=SHA1) -> std::string"""
    return _SimpleITK.Hash(*args, **kwargs)
class BSplineTransformInitializerFilter(ProcessObject):
    r"""Proxy of C++ slicer_itk::simple::BSplineTransformInitializerFilter class."""

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

    def __init__(self):
        r"""__init__(BSplineTransformInitializerFilter self) -> BSplineTransformInitializerFilter"""
        _SimpleITK.BSplineTransformInitializerFilter_swiginit(self, _SimpleITK.new_BSplineTransformInitializerFilter())
    __swig_destroy__ = _SimpleITK.delete_BSplineTransformInitializerFilter

    def SetTransformDomainMeshSize(self, TransformDomainMeshSize):
        r"""SetTransformDomainMeshSize(BSplineTransformInitializerFilter self, VectorUInt32 TransformDomainMeshSize)"""
        return _SimpleITK.BSplineTransformInitializerFilter_SetTransformDomainMeshSize(self, TransformDomainMeshSize)

    def GetTransformDomainMeshSize(self):
        r"""GetTransformDomainMeshSize(BSplineTransformInitializerFilter self) -> VectorUInt32"""
        return _SimpleITK.BSplineTransformInitializerFilter_GetTransformDomainMeshSize(self)

    def SetOrder(self, order):
        r"""SetOrder(BSplineTransformInitializerFilter self, unsigned int order)"""
        return _SimpleITK.BSplineTransformInitializerFilter_SetOrder(self, order)

    def GetOrder(self):
        r"""GetOrder(BSplineTransformInitializerFilter self) -> unsigned int"""
        return _SimpleITK.BSplineTransformInitializerFilter_GetOrder(self)

    def GetName(self):
        r"""GetName(BSplineTransformInitializerFilter self) -> std::string"""
        return _SimpleITK.BSplineTransformInitializerFilter_GetName(self)

    def __str__(self):
        r"""__str__(BSplineTransformInitializerFilter self) -> std::string"""
        return _SimpleITK.BSplineTransformInitializerFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BSplineTransformInitializerFilter self, Image image1) -> BSplineTransform"""
        return _SimpleITK.BSplineTransformInitializerFilter_Execute(self, image1)

# Register BSplineTransformInitializerFilter in _SimpleITK:
_SimpleITK.BSplineTransformInitializerFilter_swigregister(BSplineTransformInitializerFilter)

def BSplineTransformInitializer(*args, **kwargs):
    r"""BSplineTransformInitializer(Image image1, VectorUInt32 transformDomainMeshSize=std::vector< uint32_t >(3, 1u), unsigned int order=3) -> BSplineTransform"""
    return _SimpleITK.BSplineTransformInitializer(*args, **kwargs)
class CenteredTransformInitializerFilter(ProcessObject):
    r"""Proxy of C++ slicer_itk::simple::CenteredTransformInitializerFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_CenteredTransformInitializerFilter

    def __init__(self):
        r"""__init__(CenteredTransformInitializerFilter self) -> CenteredTransformInitializerFilter"""
        _SimpleITK.CenteredTransformInitializerFilter_swiginit(self, _SimpleITK.new_CenteredTransformInitializerFilter())
    GEOMETRY = _SimpleITK.CenteredTransformInitializerFilter_GEOMETRY
    
    MOMENTS = _SimpleITK.CenteredTransformInitializerFilter_MOMENTS
    

    def SetOperationMode(self, OperationMode):
        r"""SetOperationMode(CenteredTransformInitializerFilter self, slicer_itk::simple::CenteredTransformInitializerFilter::OperationModeType OperationMode)"""
        return _SimpleITK.CenteredTransformInitializerFilter_SetOperationMode(self, OperationMode)

    def GetOperationMode(self):
        r"""GetOperationMode(CenteredTransformInitializerFilter self) -> slicer_itk::simple::CenteredTransformInitializerFilter::OperationModeType"""
        return _SimpleITK.CenteredTransformInitializerFilter_GetOperationMode(self)

    def GetName(self):
        r"""GetName(CenteredTransformInitializerFilter self) -> std::string"""
        return _SimpleITK.CenteredTransformInitializerFilter_GetName(self)

    def __str__(self):
        r"""__str__(CenteredTransformInitializerFilter self) -> std::string"""
        return _SimpleITK.CenteredTransformInitializerFilter___str__(self)

    def Execute(self, fixedImage, movingImage, transform):
        r"""Execute(CenteredTransformInitializerFilter self, Image fixedImage, Image movingImage, Transform transform) -> Transform"""
        val = _SimpleITK.CenteredTransformInitializerFilter_Execute(self, fixedImage, movingImage, transform)

        val = val.Downcast()


        return val


    def MomentsOn(self):
        r"""MomentsOn(CenteredTransformInitializerFilter self)"""
        return _SimpleITK.CenteredTransformInitializerFilter_MomentsOn(self)

    def GeometryOn(self):
        r"""GeometryOn(CenteredTransformInitializerFilter self)"""
        return _SimpleITK.CenteredTransformInitializerFilter_GeometryOn(self)

# Register CenteredTransformInitializerFilter in _SimpleITK:
_SimpleITK.CenteredTransformInitializerFilter_swigregister(CenteredTransformInitializerFilter)

def CenteredTransformInitializer(*args, **kwargs):
    r"""CenteredTransformInitializer(Image fixedImage, Image movingImage, Transform transform, slicer_itk::simple::CenteredTransformInitializerFilter::OperationModeType operationMode=MOMENTS) -> Transform"""
    val = _SimpleITK.CenteredTransformInitializer(*args, **kwargs)

    val = val.Downcast()


    return val
class CenteredVersorTransformInitializerFilter(ProcessObject):
    r"""Proxy of C++ slicer_itk::simple::CenteredVersorTransformInitializerFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_CenteredVersorTransformInitializerFilter

    def __init__(self):
        r"""__init__(CenteredVersorTransformInitializerFilter self) -> CenteredVersorTransformInitializerFilter"""
        _SimpleITK.CenteredVersorTransformInitializerFilter_swiginit(self, _SimpleITK.new_CenteredVersorTransformInitializerFilter())

    def SetComputeRotation(self, ComputeRotation):
        r"""SetComputeRotation(CenteredVersorTransformInitializerFilter self, bool ComputeRotation)"""
        return _SimpleITK.CenteredVersorTransformInitializerFilter_SetComputeRotation(self, ComputeRotation)

    def ComputeRotationOn(self):
        r"""ComputeRotationOn(CenteredVersorTransformInitializerFilter self)"""
        return _SimpleITK.CenteredVersorTransformInitializerFilter_ComputeRotationOn(self)

    def ComputeRotationOff(self):
        r"""ComputeRotationOff(CenteredVersorTransformInitializerFilter self)"""
        return _SimpleITK.CenteredVersorTransformInitializerFilter_ComputeRotationOff(self)

    def GetComputeRotation(self):
        r"""GetComputeRotation(CenteredVersorTransformInitializerFilter self) -> bool"""
        return _SimpleITK.CenteredVersorTransformInitializerFilter_GetComputeRotation(self)

    def GetName(self):
        r"""GetName(CenteredVersorTransformInitializerFilter self) -> std::string"""
        return _SimpleITK.CenteredVersorTransformInitializerFilter_GetName(self)

    def __str__(self):
        r"""__str__(CenteredVersorTransformInitializerFilter self) -> std::string"""
        return _SimpleITK.CenteredVersorTransformInitializerFilter___str__(self)

    def Execute(self, fixedImage, movingImage, transform):
        r"""Execute(CenteredVersorTransformInitializerFilter self, Image fixedImage, Image movingImage, Transform transform) -> Transform"""
        return _SimpleITK.CenteredVersorTransformInitializerFilter_Execute(self, fixedImage, movingImage, transform)

# Register CenteredVersorTransformInitializerFilter in _SimpleITK:
_SimpleITK.CenteredVersorTransformInitializerFilter_swigregister(CenteredVersorTransformInitializerFilter)

def CenteredVersorTransformInitializer(fixedImage, movingImage, transform, computeRotation=False):
    r"""CenteredVersorTransformInitializer(Image fixedImage, Image movingImage, Transform transform, bool computeRotation=False) -> Transform"""
    return _SimpleITK.CenteredVersorTransformInitializer(fixedImage, movingImage, transform, computeRotation)
class LandmarkBasedTransformInitializerFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::LandmarkBasedTransformInitializerFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_LandmarkBasedTransformInitializerFilter

    def __init__(self):
        r"""__init__(LandmarkBasedTransformInitializerFilter self) -> LandmarkBasedTransformInitializerFilter"""
        _SimpleITK.LandmarkBasedTransformInitializerFilter_swiginit(self, _SimpleITK.new_LandmarkBasedTransformInitializerFilter())

    def SetFixedLandmarks(self, FixedLandmarks):
        r"""SetFixedLandmarks(LandmarkBasedTransformInitializerFilter self, VectorDouble FixedLandmarks)"""
        return _SimpleITK.LandmarkBasedTransformInitializerFilter_SetFixedLandmarks(self, FixedLandmarks)

    def GetFixedLandmarks(self):
        r"""GetFixedLandmarks(LandmarkBasedTransformInitializerFilter self) -> VectorDouble"""
        return _SimpleITK.LandmarkBasedTransformInitializerFilter_GetFixedLandmarks(self)

    def SetMovingLandmarks(self, MovingLandmarks):
        r"""SetMovingLandmarks(LandmarkBasedTransformInitializerFilter self, VectorDouble MovingLandmarks)"""
        return _SimpleITK.LandmarkBasedTransformInitializerFilter_SetMovingLandmarks(self, MovingLandmarks)

    def GetMovingLandmarks(self):
        r"""GetMovingLandmarks(LandmarkBasedTransformInitializerFilter self) -> VectorDouble"""
        return _SimpleITK.LandmarkBasedTransformInitializerFilter_GetMovingLandmarks(self)

    def SetLandmarkWeight(self, LandmarkWeight):
        r"""SetLandmarkWeight(LandmarkBasedTransformInitializerFilter self, VectorDouble LandmarkWeight)"""
        return _SimpleITK.LandmarkBasedTransformInitializerFilter_SetLandmarkWeight(self, LandmarkWeight)

    def GetLandmarkWeight(self):
        r"""GetLandmarkWeight(LandmarkBasedTransformInitializerFilter self) -> VectorDouble"""
        return _SimpleITK.LandmarkBasedTransformInitializerFilter_GetLandmarkWeight(self)

    def SetReferenceImage(self, ReferenceImage):
        r"""SetReferenceImage(LandmarkBasedTransformInitializerFilter self, Image ReferenceImage)"""
        return _SimpleITK.LandmarkBasedTransformInitializerFilter_SetReferenceImage(self, ReferenceImage)

    def GetReferenceImage(self):
        r"""GetReferenceImage(LandmarkBasedTransformInitializerFilter self) -> Image"""
        return _SimpleITK.LandmarkBasedTransformInitializerFilter_GetReferenceImage(self)

    def SetBSplineNumberOfControlPoints(self, BSplineNumberOfControlPoints):
        r"""SetBSplineNumberOfControlPoints(LandmarkBasedTransformInitializerFilter self, unsigned int BSplineNumberOfControlPoints)"""
        return _SimpleITK.LandmarkBasedTransformInitializerFilter_SetBSplineNumberOfControlPoints(self, BSplineNumberOfControlPoints)

    def GetBSplineNumberOfControlPoints(self):
        r"""GetBSplineNumberOfControlPoints(LandmarkBasedTransformInitializerFilter self) -> unsigned int"""
        return _SimpleITK.LandmarkBasedTransformInitializerFilter_GetBSplineNumberOfControlPoints(self)

    def GetName(self):
        r"""GetName(LandmarkBasedTransformInitializerFilter self) -> std::string"""
        return _SimpleITK.LandmarkBasedTransformInitializerFilter_GetName(self)

    def __str__(self):
        r"""__str__(LandmarkBasedTransformInitializerFilter self) -> std::string"""
        return _SimpleITK.LandmarkBasedTransformInitializerFilter___str__(self)

    def Execute(self, transform):
        r"""Execute(LandmarkBasedTransformInitializerFilter self, Transform transform) -> Transform"""
        val = _SimpleITK.LandmarkBasedTransformInitializerFilter_Execute(self, transform)

        val = val.Downcast()


        return val


# Register LandmarkBasedTransformInitializerFilter in _SimpleITK:
_SimpleITK.LandmarkBasedTransformInitializerFilter_swigregister(LandmarkBasedTransformInitializerFilter)

def LandmarkBasedTransformInitializer(*args, **kwargs):
    r"""LandmarkBasedTransformInitializer(Transform transform, VectorDouble fixedLandmarks=std::vector< double >(), VectorDouble movingLandmarks=std::vector< double >(), VectorDouble landmarkWeight=std::vector< double >(), Image referenceImage=slicer_itk::simple::Image(), unsigned int numberOfControlPoints=4) -> Transform"""
    val = _SimpleITK.LandmarkBasedTransformInitializer(*args, **kwargs)

    val = val.Downcast()


    return val
class CastImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::CastImageFilter class."""

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

    def SetOutputPixelType(self, pixelID):
        r"""SetOutputPixelType(CastImageFilter self, slicer_itk::simple::PixelIDValueEnum pixelID)"""
        return _SimpleITK.CastImageFilter_SetOutputPixelType(self, pixelID)

    def GetOutputPixelType(self):
        r"""GetOutputPixelType(CastImageFilter self) -> slicer_itk::simple::PixelIDValueEnum"""
        return _SimpleITK.CastImageFilter_GetOutputPixelType(self)
    __swig_destroy__ = _SimpleITK.delete_CastImageFilter

    def __init__(self):
        r"""__init__(CastImageFilter self) -> CastImageFilter"""
        _SimpleITK.CastImageFilter_swiginit(self, _SimpleITK.new_CastImageFilter())

    def GetName(self):
        r"""GetName(CastImageFilter self) -> std::string"""
        return _SimpleITK.CastImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(CastImageFilter self) -> std::string"""
        return _SimpleITK.CastImageFilter___str__(self)

    def Execute(self, arg2):
        r"""Execute(CastImageFilter self, Image arg2) -> Image"""
        return _SimpleITK.CastImageFilter_Execute(self, arg2)

# Register CastImageFilter in _SimpleITK:
_SimpleITK.CastImageFilter_swigregister(CastImageFilter)

def Cast(image, pixelID):
    r"""Cast(Image image, slicer_itk::simple::PixelIDValueEnum pixelID) -> Image"""
    return _SimpleITK.Cast(image, pixelID)
class ExtractImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ExtractImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ExtractImageFilter

    def __init__(self):
        r"""__init__(ExtractImageFilter self) -> ExtractImageFilter"""
        _SimpleITK.ExtractImageFilter_swiginit(self, _SimpleITK.new_ExtractImageFilter())

    def SetSize(self, Size):
        r"""SetSize(ExtractImageFilter self, VectorUInt32 Size)"""
        return _SimpleITK.ExtractImageFilter_SetSize(self, Size)

    def GetSize(self):
        r"""GetSize(ExtractImageFilter self) -> VectorUInt32"""
        return _SimpleITK.ExtractImageFilter_GetSize(self)

    def SetIndex(self, Index):
        r"""SetIndex(ExtractImageFilter self, VectorInt32 Index)"""
        return _SimpleITK.ExtractImageFilter_SetIndex(self, Index)

    def GetIndex(self):
        r"""GetIndex(ExtractImageFilter self) -> VectorInt32"""
        return _SimpleITK.ExtractImageFilter_GetIndex(self)
    DIRECTIONCOLLAPSETOUNKOWN = _SimpleITK.ExtractImageFilter_DIRECTIONCOLLAPSETOUNKOWN
    
    DIRECTIONCOLLAPSETOIDENTITY = _SimpleITK.ExtractImageFilter_DIRECTIONCOLLAPSETOIDENTITY
    
    DIRECTIONCOLLAPSETOSUBMATRIX = _SimpleITK.ExtractImageFilter_DIRECTIONCOLLAPSETOSUBMATRIX
    
    DIRECTIONCOLLAPSETOGUESS = _SimpleITK.ExtractImageFilter_DIRECTIONCOLLAPSETOGUESS
    

    def SetDirectionCollapseToStrategy(self, DirectionCollapseToStrategy):
        r"""SetDirectionCollapseToStrategy(ExtractImageFilter self, slicer_itk::simple::ExtractImageFilter::DirectionCollapseToStrategyType DirectionCollapseToStrategy)"""
        return _SimpleITK.ExtractImageFilter_SetDirectionCollapseToStrategy(self, DirectionCollapseToStrategy)

    def GetDirectionCollapseToStrategy(self):
        r"""GetDirectionCollapseToStrategy(ExtractImageFilter self) -> slicer_itk::simple::ExtractImageFilter::DirectionCollapseToStrategyType"""
        return _SimpleITK.ExtractImageFilter_GetDirectionCollapseToStrategy(self)

    def GetName(self):
        r"""GetName(ExtractImageFilter self) -> std::string"""
        return _SimpleITK.ExtractImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ExtractImageFilter self) -> std::string"""
        return _SimpleITK.ExtractImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ExtractImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ExtractImageFilter_Execute(self, image1)

# Register ExtractImageFilter in _SimpleITK:
_SimpleITK.ExtractImageFilter_swigregister(ExtractImageFilter)

def Extract(*args, **kwargs):
    r"""Extract(Image image1, VectorUInt32 size=std::vector< unsigned int >(5, 1), VectorInt32 index=std::vector< int >(5, 0), slicer_itk::simple::ExtractImageFilter::DirectionCollapseToStrategyType directionCollapseToStrategy=DIRECTIONCOLLAPSETOGUESS) -> Image"""
    return _SimpleITK.Extract(*args, **kwargs)
class PasteImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::PasteImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_PasteImageFilter

    def __init__(self):
        r"""__init__(PasteImageFilter self) -> PasteImageFilter"""
        _SimpleITK.PasteImageFilter_swiginit(self, _SimpleITK.new_PasteImageFilter())

    def SetSourceSize(self, SourceSize):
        r"""SetSourceSize(PasteImageFilter self, VectorUInt32 SourceSize)"""
        return _SimpleITK.PasteImageFilter_SetSourceSize(self, SourceSize)

    def GetSourceSize(self):
        r"""GetSourceSize(PasteImageFilter self) -> VectorUInt32"""
        return _SimpleITK.PasteImageFilter_GetSourceSize(self)

    def SetSourceIndex(self, SourceIndex):
        r"""SetSourceIndex(PasteImageFilter self, VectorInt32 SourceIndex)"""
        return _SimpleITK.PasteImageFilter_SetSourceIndex(self, SourceIndex)

    def GetSourceIndex(self):
        r"""GetSourceIndex(PasteImageFilter self) -> VectorInt32"""
        return _SimpleITK.PasteImageFilter_GetSourceIndex(self)

    def SetDestinationIndex(self, DestinationIndex):
        r"""SetDestinationIndex(PasteImageFilter self, VectorInt32 DestinationIndex)"""
        return _SimpleITK.PasteImageFilter_SetDestinationIndex(self, DestinationIndex)

    def GetDestinationIndex(self):
        r"""GetDestinationIndex(PasteImageFilter self) -> VectorInt32"""
        return _SimpleITK.PasteImageFilter_GetDestinationIndex(self)

    def SetDestinationSkipAxes(self, DestinationSkipAxes):
        r"""SetDestinationSkipAxes(PasteImageFilter self, VectorBool DestinationSkipAxes)"""
        return _SimpleITK.PasteImageFilter_SetDestinationSkipAxes(self, DestinationSkipAxes)

    def GetDestinationSkipAxes(self):
        r"""GetDestinationSkipAxes(PasteImageFilter self) -> VectorBool"""
        return _SimpleITK.PasteImageFilter_GetDestinationSkipAxes(self)

    def GetName(self):
        r"""GetName(PasteImageFilter self) -> std::string"""
        return _SimpleITK.PasteImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(PasteImageFilter self) -> std::string"""
        return _SimpleITK.PasteImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(PasteImageFilter self, Image destinationImage, Image sourceImage) -> Image
        Execute(PasteImageFilter self, Image destinationImage, double constant) -> Image
        """
        return _SimpleITK.PasteImageFilter_Execute(self, *args)

# Register PasteImageFilter in _SimpleITK:
_SimpleITK.PasteImageFilter_swigregister(PasteImageFilter)

def Paste(*args, **kwargs):
    r"""Paste(Image destinationImage, Image sourceImage, VectorUInt32 sourceSize=std::vector< unsigned int >(5, 1), VectorInt32 sourceIndex=std::vector< int >(5, 0), VectorInt32 destinationIndex=std::vector< int >(5, 0), VectorBool DestinationSkipAxes=std::vector< bool >()) -> Image"""
    return _SimpleITK.Paste(*args, **kwargs)

def PatchBasedDenoising(*args):
    r"""
    PatchBasedDenoising(Image image1, slicer_itk::simple::PatchBasedDenoisingImageFilter::NoiseModelType noiseModel, double kernelBandwidthSigma=400.0, uint32_t patchRadius=4, uint32_t numberOfIterations=1, uint32_t numberOfSamplePatches=200, double sampleVariance=400.0, double noiseSigma=0.0, double noiseModelFidelityWeight=0.0) -> Image
    PatchBasedDenoising(Image image1, double kernelBandwidthSigma=400.0, uint32_t patchRadius=4, uint32_t numberOfIterations=1, uint32_t numberOfSamplePatches=200, double sampleVariance=400.0) -> Image
    """
    return _SimpleITK.PatchBasedDenoising(*args)
class ImageRegistrationMethod(ProcessObject):
    r"""Proxy of C++ slicer_itk::simple::ImageRegistrationMethod class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ImageRegistrationMethod

    def __init__(self):
        r"""__init__(ImageRegistrationMethod self) -> ImageRegistrationMethod"""
        _SimpleITK.ImageRegistrationMethod_swiginit(self, _SimpleITK.new_ImageRegistrationMethod())

    def GetName(self):
        r"""GetName(ImageRegistrationMethod self) -> std::string"""
        return _SimpleITK.ImageRegistrationMethod_GetName(self)

    def __str__(self):
        r"""__str__(ImageRegistrationMethod self) -> std::string"""
        return _SimpleITK.ImageRegistrationMethod___str__(self)

    def GetInterpolator(self):
        r"""GetInterpolator(ImageRegistrationMethod self) -> slicer_itk::simple::InterpolatorEnum"""
        return _SimpleITK.ImageRegistrationMethod_GetInterpolator(self)

    def SetInterpolator(self, Interpolator):
        r"""SetInterpolator(ImageRegistrationMethod self, slicer_itk::simple::InterpolatorEnum Interpolator)"""
        return _SimpleITK.ImageRegistrationMethod_SetInterpolator(self, Interpolator)

    def SetInitialTransform(self, transform, inPlace=True):
        r"""SetInitialTransform(ImageRegistrationMethod self, Transform transform, bool inPlace=True)"""
        return _SimpleITK.ImageRegistrationMethod_SetInitialTransform(self, transform, inPlace)

    def GetInitialTransform(self):
        r"""GetInitialTransform(ImageRegistrationMethod self) -> Transform"""
        return _SimpleITK.ImageRegistrationMethod_GetInitialTransform(self)

    def GetInitialTransformInPlace(self):
        r"""GetInitialTransformInPlace(ImageRegistrationMethod self) -> bool"""
        return _SimpleITK.ImageRegistrationMethod_GetInitialTransformInPlace(self)

    def SetInitialTransformAsBSpline(self, *args, **kwargs):
        r"""SetInitialTransformAsBSpline(ImageRegistrationMethod self, BSplineTransform transform, bool inPlace=True, VectorUInt32 scaleFactors=std::vector< unsigned int >())"""
        return _SimpleITK.ImageRegistrationMethod_SetInitialTransformAsBSpline(self, *args, **kwargs)

    def SetMovingInitialTransform(self, transform):
        r"""SetMovingInitialTransform(ImageRegistrationMethod self, Transform transform)"""
        return _SimpleITK.ImageRegistrationMethod_SetMovingInitialTransform(self, transform)

    def GetMovingInitialTransform(self):
        r"""GetMovingInitialTransform(ImageRegistrationMethod self) -> Transform"""
        return _SimpleITK.ImageRegistrationMethod_GetMovingInitialTransform(self)

    def SetFixedInitialTransform(self, transform):
        r"""SetFixedInitialTransform(ImageRegistrationMethod self, Transform transform)"""
        return _SimpleITK.ImageRegistrationMethod_SetFixedInitialTransform(self, transform)

    def GetFixedInitialTransform(self):
        r"""GetFixedInitialTransform(ImageRegistrationMethod self) -> Transform"""
        return _SimpleITK.ImageRegistrationMethod_GetFixedInitialTransform(self)

    def SetVirtualDomain(self, virtualSize, virtualOrigin, virtualSpacing, virtualDirection):
        r"""SetVirtualDomain(ImageRegistrationMethod self, VectorUInt32 virtualSize, VectorDouble virtualOrigin, VectorDouble virtualSpacing, VectorDouble virtualDirection)"""
        return _SimpleITK.ImageRegistrationMethod_SetVirtualDomain(self, virtualSize, virtualOrigin, virtualSpacing, virtualDirection)

    def SetVirtualDomainFromImage(self, virtualImage):
        r"""SetVirtualDomainFromImage(ImageRegistrationMethod self, Image virtualImage)"""
        return _SimpleITK.ImageRegistrationMethod_SetVirtualDomainFromImage(self, virtualImage)

    def SetMetricAsANTSNeighborhoodCorrelation(self, radius):
        r"""SetMetricAsANTSNeighborhoodCorrelation(ImageRegistrationMethod self, unsigned int radius)"""
        return _SimpleITK.ImageRegistrationMethod_SetMetricAsANTSNeighborhoodCorrelation(self, radius)

    def SetMetricAsCorrelation(self):
        r"""SetMetricAsCorrelation(ImageRegistrationMethod self)"""
        return _SimpleITK.ImageRegistrationMethod_SetMetricAsCorrelation(self)

    def SetMetricAsDemons(self, intensityDifferenceThreshold=0.001):
        r"""SetMetricAsDemons(ImageRegistrationMethod self, double intensityDifferenceThreshold=0.001)"""
        return _SimpleITK.ImageRegistrationMethod_SetMetricAsDemons(self, intensityDifferenceThreshold)

    def SetMetricAsJointHistogramMutualInformation(self, numberOfHistogramBins=20, varianceForJointPDFSmoothing=1.5):
        r"""SetMetricAsJointHistogramMutualInformation(ImageRegistrationMethod self, unsigned int numberOfHistogramBins=20, double varianceForJointPDFSmoothing=1.5)"""
        return _SimpleITK.ImageRegistrationMethod_SetMetricAsJointHistogramMutualInformation(self, numberOfHistogramBins, varianceForJointPDFSmoothing)

    def SetMetricAsMeanSquares(self):
        r"""SetMetricAsMeanSquares(ImageRegistrationMethod self)"""
        return _SimpleITK.ImageRegistrationMethod_SetMetricAsMeanSquares(self)

    def SetMetricAsMattesMutualInformation(self, numberOfHistogramBins=50):
        r"""SetMetricAsMattesMutualInformation(ImageRegistrationMethod self, unsigned int numberOfHistogramBins=50)"""
        return _SimpleITK.ImageRegistrationMethod_SetMetricAsMattesMutualInformation(self, numberOfHistogramBins)
    Never = _SimpleITK.ImageRegistrationMethod_Never
    
    Once = _SimpleITK.ImageRegistrationMethod_Once
    
    EachIteration = _SimpleITK.ImageRegistrationMethod_EachIteration
    

    def SetOptimizerAsConjugateGradientLineSearch(self, *args, **kwargs):
        r"""SetOptimizerAsConjugateGradientLineSearch(ImageRegistrationMethod self, double learningRate, unsigned int numberOfIterations, double convergenceMinimumValue=1e-6, unsigned int convergenceWindowSize=10, double lineSearchLowerLimit=0, double lineSearchUpperLimit=5.0, double lineSearchEpsilon=0.01, unsigned int lineSearchMaximumIterations=20, slicer_itk::simple::ImageRegistrationMethod::EstimateLearningRateType estimateLearningRate=Once, double maximumStepSizeInPhysicalUnits=0.0)"""
        return _SimpleITK.ImageRegistrationMethod_SetOptimizerAsConjugateGradientLineSearch(self, *args, **kwargs)

    def SetOptimizerAsRegularStepGradientDescent(self, *args, **kwargs):
        r"""SetOptimizerAsRegularStepGradientDescent(ImageRegistrationMethod self, double learningRate, double minStep, unsigned int numberOfIterations, double relaxationFactor=0.5, double gradientMagnitudeTolerance=1e-4, slicer_itk::simple::ImageRegistrationMethod::EstimateLearningRateType estimateLearningRate=Never, double maximumStepSizeInPhysicalUnits=0.0)"""
        return _SimpleITK.ImageRegistrationMethod_SetOptimizerAsRegularStepGradientDescent(self, *args, **kwargs)

    def SetOptimizerAsGradientDescent(self, *args, **kwargs):
        r"""SetOptimizerAsGradientDescent(ImageRegistrationMethod self, double learningRate, unsigned int numberOfIterations, double convergenceMinimumValue=1e-6, unsigned int convergenceWindowSize=10, slicer_itk::simple::ImageRegistrationMethod::EstimateLearningRateType estimateLearningRate=Once, double maximumStepSizeInPhysicalUnits=0.0)"""
        return _SimpleITK.ImageRegistrationMethod_SetOptimizerAsGradientDescent(self, *args, **kwargs)

    def SetOptimizerAsGradientDescentLineSearch(self, *args, **kwargs):
        r"""SetOptimizerAsGradientDescentLineSearch(ImageRegistrationMethod self, double learningRate, unsigned int numberOfIterations, double convergenceMinimumValue=1e-6, unsigned int convergenceWindowSize=10, double lineSearchLowerLimit=0, double lineSearchUpperLimit=5.0, double lineSearchEpsilon=0.01, unsigned int lineSearchMaximumIterations=20, slicer_itk::simple::ImageRegistrationMethod::EstimateLearningRateType estimateLearningRate=Once, double maximumStepSizeInPhysicalUnits=0.0)"""
        return _SimpleITK.ImageRegistrationMethod_SetOptimizerAsGradientDescentLineSearch(self, *args, **kwargs)

    def SetOptimizerAsLBFGSB(self, *args, **kwargs):
        r"""SetOptimizerAsLBFGSB(ImageRegistrationMethod self, double gradientConvergenceTolerance=1e-5, unsigned int numberOfIterations=500, unsigned int maximumNumberOfCorrections=5, unsigned int maximumNumberOfFunctionEvaluations=2000, double costFunctionConvergenceFactor=1e+7, double lowerBound=std::numeric_limits< double >::min(), double upperBound=std::numeric_limits< double >::max(), bool trace=False)"""
        return _SimpleITK.ImageRegistrationMethod_SetOptimizerAsLBFGSB(self, *args, **kwargs)

    def SetOptimizerAsLBFGS2(self, solutionAccuracy=1e-5, numberOfIterations=0, hessianApproximateAccuracy=6, deltaConvergenceDistance=0, deltaConvergenceTolerance=1e-5, lineSearchMaximumEvaluations=40, lineSearchMinimumStep=1e-20, lineSearchMaximumStep=1e20, lineSearchAccuracy=1e-4):
        r"""SetOptimizerAsLBFGS2(ImageRegistrationMethod self, double solutionAccuracy=1e-5, unsigned int numberOfIterations=0, unsigned int hessianApproximateAccuracy=6, unsigned int deltaConvergenceDistance=0, double deltaConvergenceTolerance=1e-5, unsigned int lineSearchMaximumEvaluations=40, double lineSearchMinimumStep=1e-20, double lineSearchMaximumStep=1e20, double lineSearchAccuracy=1e-4)"""
        return _SimpleITK.ImageRegistrationMethod_SetOptimizerAsLBFGS2(self, solutionAccuracy, numberOfIterations, hessianApproximateAccuracy, deltaConvergenceDistance, deltaConvergenceTolerance, lineSearchMaximumEvaluations, lineSearchMinimumStep, lineSearchMaximumStep, lineSearchAccuracy)

    def SetOptimizerAsExhaustive(self, numberOfSteps, stepLength=1.0):
        r"""SetOptimizerAsExhaustive(ImageRegistrationMethod self, VectorUInt32 numberOfSteps, double stepLength=1.0)"""
        return _SimpleITK.ImageRegistrationMethod_SetOptimizerAsExhaustive(self, numberOfSteps, stepLength)

    def SetOptimizerAsAmoeba(self, simplexDelta, numberOfIterations, parametersConvergenceTolerance=1e-8, functionConvergenceTolerance=1e-4, withRestarts=False):
        r"""SetOptimizerAsAmoeba(ImageRegistrationMethod self, double simplexDelta, unsigned int numberOfIterations, double parametersConvergenceTolerance=1e-8, double functionConvergenceTolerance=1e-4, bool withRestarts=False)"""
        return _SimpleITK.ImageRegistrationMethod_SetOptimizerAsAmoeba(self, simplexDelta, numberOfIterations, parametersConvergenceTolerance, functionConvergenceTolerance, withRestarts)

    def SetOptimizerWeights(self, weights):
        r"""SetOptimizerWeights(ImageRegistrationMethod self, VectorDouble weights)"""
        return _SimpleITK.ImageRegistrationMethod_SetOptimizerWeights(self, weights)

    def GetOptimizerWeights(self):
        r"""GetOptimizerWeights(ImageRegistrationMethod self) -> VectorDouble"""
        return _SimpleITK.ImageRegistrationMethod_GetOptimizerWeights(self)

    def SetOptimizerAsPowell(self, numberOfIterations=100, maximumLineIterations=100, stepLength=1, stepTolerance=1e-6, valueTolerance=1e-6):
        r"""SetOptimizerAsPowell(ImageRegistrationMethod self, unsigned int numberOfIterations=100, unsigned int maximumLineIterations=100, double stepLength=1, double stepTolerance=1e-6, double valueTolerance=1e-6)"""
        return _SimpleITK.ImageRegistrationMethod_SetOptimizerAsPowell(self, numberOfIterations, maximumLineIterations, stepLength, stepTolerance, valueTolerance)

    def SetOptimizerAsOnePlusOneEvolutionary(self, *args, **kwargs):
        r"""SetOptimizerAsOnePlusOneEvolutionary(ImageRegistrationMethod self, unsigned int numberOfIterations=100, double epsilon=1.5e-4, double initialRadius=1.01, double growthFactor=-1.0, double shrinkFactor=-1.0, unsigned int seed=sitkWallClock)"""
        return _SimpleITK.ImageRegistrationMethod_SetOptimizerAsOnePlusOneEvolutionary(self, *args, **kwargs)

    def SetOptimizerScales(self, scales):
        r"""SetOptimizerScales(ImageRegistrationMethod self, VectorDouble scales)"""
        return _SimpleITK.ImageRegistrationMethod_SetOptimizerScales(self, scales)

    def SetOptimizerScalesFromJacobian(self, centralRegionRadius=5):
        r"""SetOptimizerScalesFromJacobian(ImageRegistrationMethod self, unsigned int centralRegionRadius=5)"""
        return _SimpleITK.ImageRegistrationMethod_SetOptimizerScalesFromJacobian(self, centralRegionRadius)

    def SetOptimizerScalesFromIndexShift(self, centralRegionRadius=5, smallParameterVariation=0.01):
        r"""SetOptimizerScalesFromIndexShift(ImageRegistrationMethod self, unsigned int centralRegionRadius=5, double smallParameterVariation=0.01)"""
        return _SimpleITK.ImageRegistrationMethod_SetOptimizerScalesFromIndexShift(self, centralRegionRadius, smallParameterVariation)

    def SetOptimizerScalesFromPhysicalShift(self, centralRegionRadius=5, smallParameterVariation=0.01):
        r"""SetOptimizerScalesFromPhysicalShift(ImageRegistrationMethod self, unsigned int centralRegionRadius=5, double smallParameterVariation=0.01)"""
        return _SimpleITK.ImageRegistrationMethod_SetOptimizerScalesFromPhysicalShift(self, centralRegionRadius, smallParameterVariation)

    def SetMetricFixedMask(self, binaryMask):
        r"""SetMetricFixedMask(ImageRegistrationMethod self, Image binaryMask)"""
        return _SimpleITK.ImageRegistrationMethod_SetMetricFixedMask(self, binaryMask)

    def SetMetricMovingMask(self, binaryMask):
        r"""SetMetricMovingMask(ImageRegistrationMethod self, Image binaryMask)"""
        return _SimpleITK.ImageRegistrationMethod_SetMetricMovingMask(self, binaryMask)

    def SetMetricSamplingPercentage(self, *args, **kwargs):
        r"""SetMetricSamplingPercentage(ImageRegistrationMethod self, double percentage, unsigned int seed=sitkWallClock)"""
        return _SimpleITK.ImageRegistrationMethod_SetMetricSamplingPercentage(self, *args, **kwargs)

    def SetMetricSamplingPercentagePerLevel(self, *args, **kwargs):
        r"""SetMetricSamplingPercentagePerLevel(ImageRegistrationMethod self, VectorDouble percentage, unsigned int seed=sitkWallClock)"""
        return _SimpleITK.ImageRegistrationMethod_SetMetricSamplingPercentagePerLevel(self, *args, **kwargs)

    def GetMetricSamplingPercentagePerLevel(self):
        r"""GetMetricSamplingPercentagePerLevel(ImageRegistrationMethod self) -> VectorDouble"""
        return _SimpleITK.ImageRegistrationMethod_GetMetricSamplingPercentagePerLevel(self)
    NONE = _SimpleITK.ImageRegistrationMethod_NONE
    
    REGULAR = _SimpleITK.ImageRegistrationMethod_REGULAR
    
    RANDOM = _SimpleITK.ImageRegistrationMethod_RANDOM
    

    def SetMetricSamplingStrategy(self, strategy):
        r"""SetMetricSamplingStrategy(ImageRegistrationMethod self, slicer_itk::simple::ImageRegistrationMethod::MetricSamplingStrategyType strategy)"""
        return _SimpleITK.ImageRegistrationMethod_SetMetricSamplingStrategy(self, strategy)

    def SetMetricUseFixedImageGradientFilter(self, arg2):
        r"""SetMetricUseFixedImageGradientFilter(ImageRegistrationMethod self, bool arg2)"""
        return _SimpleITK.ImageRegistrationMethod_SetMetricUseFixedImageGradientFilter(self, arg2)

    def MetricUseFixedImageGradientFilterOn(self):
        r"""MetricUseFixedImageGradientFilterOn(ImageRegistrationMethod self)"""
        return _SimpleITK.ImageRegistrationMethod_MetricUseFixedImageGradientFilterOn(self)

    def MetricUseFixedImageGradientFilterOff(self):
        r"""MetricUseFixedImageGradientFilterOff(ImageRegistrationMethod self)"""
        return _SimpleITK.ImageRegistrationMethod_MetricUseFixedImageGradientFilterOff(self)

    def SetMetricUseMovingImageGradientFilter(self, arg2):
        r"""SetMetricUseMovingImageGradientFilter(ImageRegistrationMethod self, bool arg2)"""
        return _SimpleITK.ImageRegistrationMethod_SetMetricUseMovingImageGradientFilter(self, arg2)

    def MetricUseMovingImageGradientFilterOn(self):
        r"""MetricUseMovingImageGradientFilterOn(ImageRegistrationMethod self)"""
        return _SimpleITK.ImageRegistrationMethod_MetricUseMovingImageGradientFilterOn(self)

    def MetricUseMovingImageGradientFilterOff(self):
        r"""MetricUseMovingImageGradientFilterOff(ImageRegistrationMethod self)"""
        return _SimpleITK.ImageRegistrationMethod_MetricUseMovingImageGradientFilterOff(self)

    def SetShrinkFactorsPerLevel(self, shrinkFactors):
        r"""SetShrinkFactorsPerLevel(ImageRegistrationMethod self, VectorUInt32 shrinkFactors)"""
        return _SimpleITK.ImageRegistrationMethod_SetShrinkFactorsPerLevel(self, shrinkFactors)

    def SetSmoothingSigmasPerLevel(self, smoothingSigmas):
        r"""SetSmoothingSigmasPerLevel(ImageRegistrationMethod self, VectorDouble smoothingSigmas)"""
        return _SimpleITK.ImageRegistrationMethod_SetSmoothingSigmasPerLevel(self, smoothingSigmas)

    def SetSmoothingSigmasAreSpecifiedInPhysicalUnits(self, arg):
        r"""SetSmoothingSigmasAreSpecifiedInPhysicalUnits(ImageRegistrationMethod self, bool arg)"""
        return _SimpleITK.ImageRegistrationMethod_SetSmoothingSigmasAreSpecifiedInPhysicalUnits(self, arg)

    def SmoothingSigmasAreSpecifiedInPhysicalUnitsOn(self):
        r"""SmoothingSigmasAreSpecifiedInPhysicalUnitsOn(ImageRegistrationMethod self)"""
        return _SimpleITK.ImageRegistrationMethod_SmoothingSigmasAreSpecifiedInPhysicalUnitsOn(self)

    def SmoothingSigmasAreSpecifiedInPhysicalUnitsOff(self):
        r"""SmoothingSigmasAreSpecifiedInPhysicalUnitsOff(ImageRegistrationMethod self)"""
        return _SimpleITK.ImageRegistrationMethod_SmoothingSigmasAreSpecifiedInPhysicalUnitsOff(self)

    def Execute(self, fixed, moving):
        r"""Execute(ImageRegistrationMethod self, Image fixed, Image moving) -> Transform"""
        val = _SimpleITK.ImageRegistrationMethod_Execute(self, fixed, moving)

        val = val.Downcast()


        return val


    def MetricEvaluate(self, fixed, moving):
        r"""MetricEvaluate(ImageRegistrationMethod self, Image fixed, Image moving) -> double"""
        return _SimpleITK.ImageRegistrationMethod_MetricEvaluate(self, fixed, moving)

    def GetOptimizerIteration(self):
        r"""GetOptimizerIteration(ImageRegistrationMethod self) -> unsigned int"""
        return _SimpleITK.ImageRegistrationMethod_GetOptimizerIteration(self)

    def GetOptimizerPosition(self):
        r"""GetOptimizerPosition(ImageRegistrationMethod self) -> VectorDouble"""
        return _SimpleITK.ImageRegistrationMethod_GetOptimizerPosition(self)

    def GetOptimizerLearningRate(self):
        r"""GetOptimizerLearningRate(ImageRegistrationMethod self) -> double"""
        return _SimpleITK.ImageRegistrationMethod_GetOptimizerLearningRate(self)

    def GetOptimizerConvergenceValue(self):
        r"""GetOptimizerConvergenceValue(ImageRegistrationMethod self) -> double"""
        return _SimpleITK.ImageRegistrationMethod_GetOptimizerConvergenceValue(self)

    def GetMetricValue(self):
        r"""GetMetricValue(ImageRegistrationMethod self) -> double"""
        return _SimpleITK.ImageRegistrationMethod_GetMetricValue(self)

    def GetMetricNumberOfValidPoints(self):
        r"""GetMetricNumberOfValidPoints(ImageRegistrationMethod self) -> uint64_t"""
        return _SimpleITK.ImageRegistrationMethod_GetMetricNumberOfValidPoints(self)

    def GetCurrentLevel(self):
        r"""GetCurrentLevel(ImageRegistrationMethod self) -> unsigned int"""
        return _SimpleITK.ImageRegistrationMethod_GetCurrentLevel(self)

    def GetOptimizerScales(self):
        r"""GetOptimizerScales(ImageRegistrationMethod self) -> VectorDouble"""
        return _SimpleITK.ImageRegistrationMethod_GetOptimizerScales(self)

    def GetOptimizerStopConditionDescription(self):
        r"""GetOptimizerStopConditionDescription(ImageRegistrationMethod self) -> std::string"""
        return _SimpleITK.ImageRegistrationMethod_GetOptimizerStopConditionDescription(self)

    def StopRegistration(self):
        r"""StopRegistration(ImageRegistrationMethod self) -> bool"""
        return _SimpleITK.ImageRegistrationMethod_StopRegistration(self)

# Register ImageRegistrationMethod in _SimpleITK:
_SimpleITK.ImageRegistrationMethod_swigregister(ImageRegistrationMethod)
class AbsImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::AbsImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_AbsImageFilter

    def __init__(self):
        r"""__init__(AbsImageFilter self) -> AbsImageFilter"""
        _SimpleITK.AbsImageFilter_swiginit(self, _SimpleITK.new_AbsImageFilter())

    def GetName(self):
        r"""GetName(AbsImageFilter self) -> std::string"""
        return _SimpleITK.AbsImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(AbsImageFilter self) -> std::string"""
        return _SimpleITK.AbsImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(AbsImageFilter self, Image image1) -> Image"""
        return _SimpleITK.AbsImageFilter_Execute(self, image1)

# Register AbsImageFilter in _SimpleITK:
_SimpleITK.AbsImageFilter_swigregister(AbsImageFilter)

def Abs(image1):
    r"""Abs(Image image1) -> Image"""
    return _SimpleITK.Abs(image1)
class AbsoluteValueDifferenceImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::AbsoluteValueDifferenceImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_AbsoluteValueDifferenceImageFilter

    def __init__(self):
        r"""__init__(AbsoluteValueDifferenceImageFilter self) -> AbsoluteValueDifferenceImageFilter"""
        _SimpleITK.AbsoluteValueDifferenceImageFilter_swiginit(self, _SimpleITK.new_AbsoluteValueDifferenceImageFilter())

    def GetName(self):
        r"""GetName(AbsoluteValueDifferenceImageFilter self) -> std::string"""
        return _SimpleITK.AbsoluteValueDifferenceImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(AbsoluteValueDifferenceImageFilter self) -> std::string"""
        return _SimpleITK.AbsoluteValueDifferenceImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(AbsoluteValueDifferenceImageFilter self, Image image1, Image image2) -> Image
        Execute(AbsoluteValueDifferenceImageFilter self, Image image1, double constant) -> Image
        Execute(AbsoluteValueDifferenceImageFilter self, double constant, Image image2) -> Image
        """
        return _SimpleITK.AbsoluteValueDifferenceImageFilter_Execute(self, *args)

# Register AbsoluteValueDifferenceImageFilter in _SimpleITK:
_SimpleITK.AbsoluteValueDifferenceImageFilter_swigregister(AbsoluteValueDifferenceImageFilter)

def AbsoluteValueDifference(*args):
    r"""
    AbsoluteValueDifference(Image image1, Image image2) -> Image
    AbsoluteValueDifference(Image image1, double constant) -> Image
    AbsoluteValueDifference(double constant, Image image2) -> Image
    """
    return _SimpleITK.AbsoluteValueDifference(*args)
class AcosImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::AcosImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_AcosImageFilter

    def __init__(self):
        r"""__init__(AcosImageFilter self) -> AcosImageFilter"""
        _SimpleITK.AcosImageFilter_swiginit(self, _SimpleITK.new_AcosImageFilter())

    def GetName(self):
        r"""GetName(AcosImageFilter self) -> std::string"""
        return _SimpleITK.AcosImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(AcosImageFilter self) -> std::string"""
        return _SimpleITK.AcosImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(AcosImageFilter self, Image image1) -> Image"""
        return _SimpleITK.AcosImageFilter_Execute(self, image1)

# Register AcosImageFilter in _SimpleITK:
_SimpleITK.AcosImageFilter_swigregister(AcosImageFilter)

def Acos(image1):
    r"""Acos(Image image1) -> Image"""
    return _SimpleITK.Acos(image1)
class AdaptiveHistogramEqualizationImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::AdaptiveHistogramEqualizationImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_AdaptiveHistogramEqualizationImageFilter

    def __init__(self):
        r"""__init__(AdaptiveHistogramEqualizationImageFilter self) -> AdaptiveHistogramEqualizationImageFilter"""
        _SimpleITK.AdaptiveHistogramEqualizationImageFilter_swiginit(self, _SimpleITK.new_AdaptiveHistogramEqualizationImageFilter())

    def SetRadius(self, *args):
        r"""
        SetRadius(AdaptiveHistogramEqualizationImageFilter self, VectorUInt32 Radius)
        SetRadius(AdaptiveHistogramEqualizationImageFilter self, unsigned int value)
        """
        return _SimpleITK.AdaptiveHistogramEqualizationImageFilter_SetRadius(self, *args)

    def GetRadius(self):
        r"""GetRadius(AdaptiveHistogramEqualizationImageFilter self) -> VectorUInt32"""
        return _SimpleITK.AdaptiveHistogramEqualizationImageFilter_GetRadius(self)

    def SetAlpha(self, Alpha):
        r"""SetAlpha(AdaptiveHistogramEqualizationImageFilter self, float Alpha)"""
        return _SimpleITK.AdaptiveHistogramEqualizationImageFilter_SetAlpha(self, Alpha)

    def GetAlpha(self):
        r"""GetAlpha(AdaptiveHistogramEqualizationImageFilter self) -> float"""
        return _SimpleITK.AdaptiveHistogramEqualizationImageFilter_GetAlpha(self)

    def SetBeta(self, Beta):
        r"""SetBeta(AdaptiveHistogramEqualizationImageFilter self, float Beta)"""
        return _SimpleITK.AdaptiveHistogramEqualizationImageFilter_SetBeta(self, Beta)

    def GetBeta(self):
        r"""GetBeta(AdaptiveHistogramEqualizationImageFilter self) -> float"""
        return _SimpleITK.AdaptiveHistogramEqualizationImageFilter_GetBeta(self)

    def GetName(self):
        r"""GetName(AdaptiveHistogramEqualizationImageFilter self) -> std::string"""
        return _SimpleITK.AdaptiveHistogramEqualizationImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(AdaptiveHistogramEqualizationImageFilter self) -> std::string"""
        return _SimpleITK.AdaptiveHistogramEqualizationImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(AdaptiveHistogramEqualizationImageFilter self, Image image1) -> Image"""
        return _SimpleITK.AdaptiveHistogramEqualizationImageFilter_Execute(self, image1)

# Register AdaptiveHistogramEqualizationImageFilter in _SimpleITK:
_SimpleITK.AdaptiveHistogramEqualizationImageFilter_swigregister(AdaptiveHistogramEqualizationImageFilter)

def AdaptiveHistogramEqualization(*args, **kwargs):
    r"""AdaptiveHistogramEqualization(Image image1, VectorUInt32 radius=std::vector< unsigned int >(3, 5), float alpha=0.3, float beta=0.3) -> Image"""
    return _SimpleITK.AdaptiveHistogramEqualization(*args, **kwargs)
class AddImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::AddImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_AddImageFilter

    def __init__(self):
        r"""__init__(AddImageFilter self) -> AddImageFilter"""
        _SimpleITK.AddImageFilter_swiginit(self, _SimpleITK.new_AddImageFilter())

    def GetName(self):
        r"""GetName(AddImageFilter self) -> std::string"""
        return _SimpleITK.AddImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(AddImageFilter self) -> std::string"""
        return _SimpleITK.AddImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(AddImageFilter self, Image image1, Image image2) -> Image
        Execute(AddImageFilter self, Image image1, double constant) -> Image
        Execute(AddImageFilter self, double constant, Image image2) -> Image
        """
        return _SimpleITK.AddImageFilter_Execute(self, *args)

# Register AddImageFilter in _SimpleITK:
_SimpleITK.AddImageFilter_swigregister(AddImageFilter)

def Add(*args):
    r"""
    Add(Image image1, Image image2) -> Image
    Add(Image image1, double constant) -> Image
    Add(double constant, Image image2) -> Image
    """
    return _SimpleITK.Add(*args)
class AdditiveGaussianNoiseImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::AdditiveGaussianNoiseImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_AdditiveGaussianNoiseImageFilter

    def __init__(self):
        r"""__init__(AdditiveGaussianNoiseImageFilter self) -> AdditiveGaussianNoiseImageFilter"""
        _SimpleITK.AdditiveGaussianNoiseImageFilter_swiginit(self, _SimpleITK.new_AdditiveGaussianNoiseImageFilter())

    def SetStandardDeviation(self, StandardDeviation):
        r"""SetStandardDeviation(AdditiveGaussianNoiseImageFilter self, double StandardDeviation)"""
        return _SimpleITK.AdditiveGaussianNoiseImageFilter_SetStandardDeviation(self, StandardDeviation)

    def GetStandardDeviation(self):
        r"""GetStandardDeviation(AdditiveGaussianNoiseImageFilter self) -> double"""
        return _SimpleITK.AdditiveGaussianNoiseImageFilter_GetStandardDeviation(self)

    def SetMean(self, Mean):
        r"""SetMean(AdditiveGaussianNoiseImageFilter self, double Mean)"""
        return _SimpleITK.AdditiveGaussianNoiseImageFilter_SetMean(self, Mean)

    def GetMean(self):
        r"""GetMean(AdditiveGaussianNoiseImageFilter self) -> double"""
        return _SimpleITK.AdditiveGaussianNoiseImageFilter_GetMean(self)

    def SetSeed(self, Seed):
        r"""SetSeed(AdditiveGaussianNoiseImageFilter self, uint32_t Seed)"""
        return _SimpleITK.AdditiveGaussianNoiseImageFilter_SetSeed(self, Seed)

    def GetSeed(self):
        r"""GetSeed(AdditiveGaussianNoiseImageFilter self) -> uint32_t"""
        return _SimpleITK.AdditiveGaussianNoiseImageFilter_GetSeed(self)

    def GetName(self):
        r"""GetName(AdditiveGaussianNoiseImageFilter self) -> std::string"""
        return _SimpleITK.AdditiveGaussianNoiseImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(AdditiveGaussianNoiseImageFilter self) -> std::string"""
        return _SimpleITK.AdditiveGaussianNoiseImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(AdditiveGaussianNoiseImageFilter self, Image image1) -> Image"""
        return _SimpleITK.AdditiveGaussianNoiseImageFilter_Execute(self, image1)

# Register AdditiveGaussianNoiseImageFilter in _SimpleITK:
_SimpleITK.AdditiveGaussianNoiseImageFilter_swigregister(AdditiveGaussianNoiseImageFilter)

def AdditiveGaussianNoise(*args, **kwargs):
    r"""AdditiveGaussianNoise(Image image1, double standardDeviation=1.0, double mean=0.0, uint32_t seed=(uint32_t) slicer_itk::simple::sitkWallClock) -> Image"""
    return _SimpleITK.AdditiveGaussianNoise(*args, **kwargs)
class AggregateLabelMapFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::AggregateLabelMapFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_AggregateLabelMapFilter

    def __init__(self):
        r"""__init__(AggregateLabelMapFilter self) -> AggregateLabelMapFilter"""
        _SimpleITK.AggregateLabelMapFilter_swiginit(self, _SimpleITK.new_AggregateLabelMapFilter())

    def GetName(self):
        r"""GetName(AggregateLabelMapFilter self) -> std::string"""
        return _SimpleITK.AggregateLabelMapFilter_GetName(self)

    def __str__(self):
        r"""__str__(AggregateLabelMapFilter self) -> std::string"""
        return _SimpleITK.AggregateLabelMapFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(AggregateLabelMapFilter self, Image image1) -> Image"""
        return _SimpleITK.AggregateLabelMapFilter_Execute(self, image1)

# Register AggregateLabelMapFilter in _SimpleITK:
_SimpleITK.AggregateLabelMapFilter_swigregister(AggregateLabelMapFilter)

def AggregateLabelMap(image1):
    r"""AggregateLabelMap(Image image1) -> Image"""
    return _SimpleITK.AggregateLabelMap(image1)
class AndImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::AndImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_AndImageFilter

    def __init__(self):
        r"""__init__(AndImageFilter self) -> AndImageFilter"""
        _SimpleITK.AndImageFilter_swiginit(self, _SimpleITK.new_AndImageFilter())

    def GetName(self):
        r"""GetName(AndImageFilter self) -> std::string"""
        return _SimpleITK.AndImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(AndImageFilter self) -> std::string"""
        return _SimpleITK.AndImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(AndImageFilter self, Image image1, Image image2) -> Image
        Execute(AndImageFilter self, Image image1, int constant) -> Image
        Execute(AndImageFilter self, int constant, Image image2) -> Image
        """
        return _SimpleITK.AndImageFilter_Execute(self, *args)

# Register AndImageFilter in _SimpleITK:
_SimpleITK.AndImageFilter_swigregister(AndImageFilter)

def And(*args):
    r"""
    And(Image image1, Image image2) -> Image
    And(Image image1, int constant) -> Image
    And(int constant, Image image2) -> Image
    """
    return _SimpleITK.And(*args)
class AntiAliasBinaryImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::AntiAliasBinaryImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_AntiAliasBinaryImageFilter

    def __init__(self):
        r"""__init__(AntiAliasBinaryImageFilter self) -> AntiAliasBinaryImageFilter"""
        _SimpleITK.AntiAliasBinaryImageFilter_swiginit(self, _SimpleITK.new_AntiAliasBinaryImageFilter())

    def SetMaximumRMSError(self, MaximumRMSError):
        r"""SetMaximumRMSError(AntiAliasBinaryImageFilter self, double MaximumRMSError)"""
        return _SimpleITK.AntiAliasBinaryImageFilter_SetMaximumRMSError(self, MaximumRMSError)

    def GetMaximumRMSError(self):
        r"""GetMaximumRMSError(AntiAliasBinaryImageFilter self) -> double"""
        return _SimpleITK.AntiAliasBinaryImageFilter_GetMaximumRMSError(self)

    def SetNumberOfIterations(self, NumberOfIterations):
        r"""SetNumberOfIterations(AntiAliasBinaryImageFilter self, uint32_t NumberOfIterations)"""
        return _SimpleITK.AntiAliasBinaryImageFilter_SetNumberOfIterations(self, NumberOfIterations)

    def GetNumberOfIterations(self):
        r"""GetNumberOfIterations(AntiAliasBinaryImageFilter self) -> uint32_t"""
        return _SimpleITK.AntiAliasBinaryImageFilter_GetNumberOfIterations(self)

    def GetElapsedIterations(self):
        r"""GetElapsedIterations(AntiAliasBinaryImageFilter self) -> uint32_t"""
        return _SimpleITK.AntiAliasBinaryImageFilter_GetElapsedIterations(self)

    def GetRMSChange(self):
        r"""GetRMSChange(AntiAliasBinaryImageFilter self) -> double"""
        return _SimpleITK.AntiAliasBinaryImageFilter_GetRMSChange(self)

    def GetName(self):
        r"""GetName(AntiAliasBinaryImageFilter self) -> std::string"""
        return _SimpleITK.AntiAliasBinaryImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(AntiAliasBinaryImageFilter self) -> std::string"""
        return _SimpleITK.AntiAliasBinaryImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(AntiAliasBinaryImageFilter self, Image image1) -> Image"""
        return _SimpleITK.AntiAliasBinaryImageFilter_Execute(self, image1)

# Register AntiAliasBinaryImageFilter in _SimpleITK:
_SimpleITK.AntiAliasBinaryImageFilter_swigregister(AntiAliasBinaryImageFilter)

def AntiAliasBinary(image1, maximumRMSError=0.07, numberOfIterations=1000):
    r"""AntiAliasBinary(Image image1, double maximumRMSError=0.07, uint32_t numberOfIterations=1000) -> Image"""
    return _SimpleITK.AntiAliasBinary(image1, maximumRMSError, numberOfIterations)
class ApproximateSignedDistanceMapImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ApproximateSignedDistanceMapImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ApproximateSignedDistanceMapImageFilter

    def __init__(self):
        r"""__init__(ApproximateSignedDistanceMapImageFilter self) -> ApproximateSignedDistanceMapImageFilter"""
        _SimpleITK.ApproximateSignedDistanceMapImageFilter_swiginit(self, _SimpleITK.new_ApproximateSignedDistanceMapImageFilter())

    def SetInsideValue(self, InsideValue):
        r"""SetInsideValue(ApproximateSignedDistanceMapImageFilter self, double InsideValue)"""
        return _SimpleITK.ApproximateSignedDistanceMapImageFilter_SetInsideValue(self, InsideValue)

    def GetInsideValue(self):
        r"""GetInsideValue(ApproximateSignedDistanceMapImageFilter self) -> double"""
        return _SimpleITK.ApproximateSignedDistanceMapImageFilter_GetInsideValue(self)

    def SetOutsideValue(self, OutsideValue):
        r"""SetOutsideValue(ApproximateSignedDistanceMapImageFilter self, double OutsideValue)"""
        return _SimpleITK.ApproximateSignedDistanceMapImageFilter_SetOutsideValue(self, OutsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(ApproximateSignedDistanceMapImageFilter self) -> double"""
        return _SimpleITK.ApproximateSignedDistanceMapImageFilter_GetOutsideValue(self)

    def GetName(self):
        r"""GetName(ApproximateSignedDistanceMapImageFilter self) -> std::string"""
        return _SimpleITK.ApproximateSignedDistanceMapImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ApproximateSignedDistanceMapImageFilter self) -> std::string"""
        return _SimpleITK.ApproximateSignedDistanceMapImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ApproximateSignedDistanceMapImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ApproximateSignedDistanceMapImageFilter_Execute(self, image1)

# Register ApproximateSignedDistanceMapImageFilter in _SimpleITK:
_SimpleITK.ApproximateSignedDistanceMapImageFilter_swigregister(ApproximateSignedDistanceMapImageFilter)

def ApproximateSignedDistanceMap(image1, insideValue=1, outsideValue=0):
    r"""ApproximateSignedDistanceMap(Image image1, double insideValue=1, double outsideValue=0) -> Image"""
    return _SimpleITK.ApproximateSignedDistanceMap(image1, insideValue, outsideValue)
class AreaClosingImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::AreaClosingImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_AreaClosingImageFilter

    def __init__(self):
        r"""__init__(AreaClosingImageFilter self) -> AreaClosingImageFilter"""
        _SimpleITK.AreaClosingImageFilter_swiginit(self, _SimpleITK.new_AreaClosingImageFilter())

    def SetLambda(self, Lambda):
        r"""SetLambda(AreaClosingImageFilter self, double Lambda)"""
        return _SimpleITK.AreaClosingImageFilter_SetLambda(self, Lambda)

    def GetLambda(self):
        r"""GetLambda(AreaClosingImageFilter self) -> double"""
        return _SimpleITK.AreaClosingImageFilter_GetLambda(self)

    def SetUseImageSpacing(self, UseImageSpacing):
        r"""SetUseImageSpacing(AreaClosingImageFilter self, bool UseImageSpacing)"""
        return _SimpleITK.AreaClosingImageFilter_SetUseImageSpacing(self, UseImageSpacing)

    def UseImageSpacingOn(self):
        r"""UseImageSpacingOn(AreaClosingImageFilter self)"""
        return _SimpleITK.AreaClosingImageFilter_UseImageSpacingOn(self)

    def UseImageSpacingOff(self):
        r"""UseImageSpacingOff(AreaClosingImageFilter self)"""
        return _SimpleITK.AreaClosingImageFilter_UseImageSpacingOff(self)

    def GetUseImageSpacing(self):
        r"""GetUseImageSpacing(AreaClosingImageFilter self) -> bool"""
        return _SimpleITK.AreaClosingImageFilter_GetUseImageSpacing(self)

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(AreaClosingImageFilter self, bool FullyConnected)"""
        return _SimpleITK.AreaClosingImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(AreaClosingImageFilter self)"""
        return _SimpleITK.AreaClosingImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(AreaClosingImageFilter self)"""
        return _SimpleITK.AreaClosingImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(AreaClosingImageFilter self) -> bool"""
        return _SimpleITK.AreaClosingImageFilter_GetFullyConnected(self)

    def GetName(self):
        r"""GetName(AreaClosingImageFilter self) -> std::string"""
        return _SimpleITK.AreaClosingImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(AreaClosingImageFilter self) -> std::string"""
        return _SimpleITK.AreaClosingImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(AreaClosingImageFilter self, Image image1) -> Image"""
        return _SimpleITK.AreaClosingImageFilter_Execute(self, image1)

# Register AreaClosingImageFilter in _SimpleITK:
_SimpleITK.AreaClosingImageFilter_swigregister(AreaClosingImageFilter)

def AreaClosing(image1, _lambda=0.0, useImageSpacing=True, fullyConnected=False):
    r"""AreaClosing(Image image1, double _lambda=0.0, bool useImageSpacing=True, bool fullyConnected=False) -> Image"""
    return _SimpleITK.AreaClosing(image1, _lambda, useImageSpacing, fullyConnected)
class AreaOpeningImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::AreaOpeningImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_AreaOpeningImageFilter

    def __init__(self):
        r"""__init__(AreaOpeningImageFilter self) -> AreaOpeningImageFilter"""
        _SimpleITK.AreaOpeningImageFilter_swiginit(self, _SimpleITK.new_AreaOpeningImageFilter())

    def SetLambda(self, Lambda):
        r"""SetLambda(AreaOpeningImageFilter self, double Lambda)"""
        return _SimpleITK.AreaOpeningImageFilter_SetLambda(self, Lambda)

    def GetLambda(self):
        r"""GetLambda(AreaOpeningImageFilter self) -> double"""
        return _SimpleITK.AreaOpeningImageFilter_GetLambda(self)

    def SetUseImageSpacing(self, UseImageSpacing):
        r"""SetUseImageSpacing(AreaOpeningImageFilter self, bool UseImageSpacing)"""
        return _SimpleITK.AreaOpeningImageFilter_SetUseImageSpacing(self, UseImageSpacing)

    def UseImageSpacingOn(self):
        r"""UseImageSpacingOn(AreaOpeningImageFilter self)"""
        return _SimpleITK.AreaOpeningImageFilter_UseImageSpacingOn(self)

    def UseImageSpacingOff(self):
        r"""UseImageSpacingOff(AreaOpeningImageFilter self)"""
        return _SimpleITK.AreaOpeningImageFilter_UseImageSpacingOff(self)

    def GetUseImageSpacing(self):
        r"""GetUseImageSpacing(AreaOpeningImageFilter self) -> bool"""
        return _SimpleITK.AreaOpeningImageFilter_GetUseImageSpacing(self)

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(AreaOpeningImageFilter self, bool FullyConnected)"""
        return _SimpleITK.AreaOpeningImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(AreaOpeningImageFilter self)"""
        return _SimpleITK.AreaOpeningImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(AreaOpeningImageFilter self)"""
        return _SimpleITK.AreaOpeningImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(AreaOpeningImageFilter self) -> bool"""
        return _SimpleITK.AreaOpeningImageFilter_GetFullyConnected(self)

    def GetName(self):
        r"""GetName(AreaOpeningImageFilter self) -> std::string"""
        return _SimpleITK.AreaOpeningImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(AreaOpeningImageFilter self) -> std::string"""
        return _SimpleITK.AreaOpeningImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(AreaOpeningImageFilter self, Image image1) -> Image"""
        return _SimpleITK.AreaOpeningImageFilter_Execute(self, image1)

# Register AreaOpeningImageFilter in _SimpleITK:
_SimpleITK.AreaOpeningImageFilter_swigregister(AreaOpeningImageFilter)

def AreaOpening(image1, _lambda=0.0, useImageSpacing=True, fullyConnected=False):
    r"""AreaOpening(Image image1, double _lambda=0.0, bool useImageSpacing=True, bool fullyConnected=False) -> Image"""
    return _SimpleITK.AreaOpening(image1, _lambda, useImageSpacing, fullyConnected)
class AsinImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::AsinImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_AsinImageFilter

    def __init__(self):
        r"""__init__(AsinImageFilter self) -> AsinImageFilter"""
        _SimpleITK.AsinImageFilter_swiginit(self, _SimpleITK.new_AsinImageFilter())

    def GetName(self):
        r"""GetName(AsinImageFilter self) -> std::string"""
        return _SimpleITK.AsinImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(AsinImageFilter self) -> std::string"""
        return _SimpleITK.AsinImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(AsinImageFilter self, Image image1) -> Image"""
        return _SimpleITK.AsinImageFilter_Execute(self, image1)

# Register AsinImageFilter in _SimpleITK:
_SimpleITK.AsinImageFilter_swigregister(AsinImageFilter)

def Asin(image1):
    r"""Asin(Image image1) -> Image"""
    return _SimpleITK.Asin(image1)
class Atan2ImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::Atan2ImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_Atan2ImageFilter

    def __init__(self):
        r"""__init__(Atan2ImageFilter self) -> Atan2ImageFilter"""
        _SimpleITK.Atan2ImageFilter_swiginit(self, _SimpleITK.new_Atan2ImageFilter())

    def GetName(self):
        r"""GetName(Atan2ImageFilter self) -> std::string"""
        return _SimpleITK.Atan2ImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(Atan2ImageFilter self) -> std::string"""
        return _SimpleITK.Atan2ImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(Atan2ImageFilter self, Image image1, Image image2) -> Image
        Execute(Atan2ImageFilter self, Image image1, double constant) -> Image
        Execute(Atan2ImageFilter self, double constant, Image image2) -> Image
        """
        return _SimpleITK.Atan2ImageFilter_Execute(self, *args)

# Register Atan2ImageFilter in _SimpleITK:
_SimpleITK.Atan2ImageFilter_swigregister(Atan2ImageFilter)

def Atan2(*args):
    r"""
    Atan2(Image image1, Image image2) -> Image
    Atan2(Image image1, double constant) -> Image
    Atan2(double constant, Image image2) -> Image
    """
    return _SimpleITK.Atan2(*args)
class AtanImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::AtanImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_AtanImageFilter

    def __init__(self):
        r"""__init__(AtanImageFilter self) -> AtanImageFilter"""
        _SimpleITK.AtanImageFilter_swiginit(self, _SimpleITK.new_AtanImageFilter())

    def GetName(self):
        r"""GetName(AtanImageFilter self) -> std::string"""
        return _SimpleITK.AtanImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(AtanImageFilter self) -> std::string"""
        return _SimpleITK.AtanImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(AtanImageFilter self, Image image1) -> Image"""
        return _SimpleITK.AtanImageFilter_Execute(self, image1)

# Register AtanImageFilter in _SimpleITK:
_SimpleITK.AtanImageFilter_swigregister(AtanImageFilter)

def Atan(image1):
    r"""Atan(Image image1) -> Image"""
    return _SimpleITK.Atan(image1)
class BSplineDecompositionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BSplineDecompositionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BSplineDecompositionImageFilter

    def __init__(self):
        r"""__init__(BSplineDecompositionImageFilter self) -> BSplineDecompositionImageFilter"""
        _SimpleITK.BSplineDecompositionImageFilter_swiginit(self, _SimpleITK.new_BSplineDecompositionImageFilter())

    def SetSplineOrder(self, SplineOrder):
        r"""SetSplineOrder(BSplineDecompositionImageFilter self, uint32_t SplineOrder)"""
        return _SimpleITK.BSplineDecompositionImageFilter_SetSplineOrder(self, SplineOrder)

    def GetSplineOrder(self):
        r"""GetSplineOrder(BSplineDecompositionImageFilter self) -> uint32_t"""
        return _SimpleITK.BSplineDecompositionImageFilter_GetSplineOrder(self)

    def GetSplinePoles(self):
        r"""GetSplinePoles(BSplineDecompositionImageFilter self) -> VectorDouble"""
        return _SimpleITK.BSplineDecompositionImageFilter_GetSplinePoles(self)

    def GetName(self):
        r"""GetName(BSplineDecompositionImageFilter self) -> std::string"""
        return _SimpleITK.BSplineDecompositionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BSplineDecompositionImageFilter self) -> std::string"""
        return _SimpleITK.BSplineDecompositionImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BSplineDecompositionImageFilter self, Image image1) -> Image"""
        return _SimpleITK.BSplineDecompositionImageFilter_Execute(self, image1)

# Register BSplineDecompositionImageFilter in _SimpleITK:
_SimpleITK.BSplineDecompositionImageFilter_swigregister(BSplineDecompositionImageFilter)

def BSplineDecomposition(image1, splineOrder=3):
    r"""BSplineDecomposition(Image image1, uint32_t splineOrder=3) -> Image"""
    return _SimpleITK.BSplineDecomposition(image1, splineOrder)
class BilateralImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BilateralImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BilateralImageFilter

    def __init__(self):
        r"""__init__(BilateralImageFilter self) -> BilateralImageFilter"""
        _SimpleITK.BilateralImageFilter_swiginit(self, _SimpleITK.new_BilateralImageFilter())

    def SetDomainSigma(self, DomainSigma):
        r"""SetDomainSigma(BilateralImageFilter self, double DomainSigma)"""
        return _SimpleITK.BilateralImageFilter_SetDomainSigma(self, DomainSigma)

    def GetDomainSigma(self):
        r"""GetDomainSigma(BilateralImageFilter self) -> double"""
        return _SimpleITK.BilateralImageFilter_GetDomainSigma(self)

    def SetRangeSigma(self, RangeSigma):
        r"""SetRangeSigma(BilateralImageFilter self, double RangeSigma)"""
        return _SimpleITK.BilateralImageFilter_SetRangeSigma(self, RangeSigma)

    def GetRangeSigma(self):
        r"""GetRangeSigma(BilateralImageFilter self) -> double"""
        return _SimpleITK.BilateralImageFilter_GetRangeSigma(self)

    def SetNumberOfRangeGaussianSamples(self, NumberOfRangeGaussianSamples):
        r"""SetNumberOfRangeGaussianSamples(BilateralImageFilter self, unsigned int NumberOfRangeGaussianSamples)"""
        return _SimpleITK.BilateralImageFilter_SetNumberOfRangeGaussianSamples(self, NumberOfRangeGaussianSamples)

    def GetNumberOfRangeGaussianSamples(self):
        r"""GetNumberOfRangeGaussianSamples(BilateralImageFilter self) -> unsigned int"""
        return _SimpleITK.BilateralImageFilter_GetNumberOfRangeGaussianSamples(self)

    def GetName(self):
        r"""GetName(BilateralImageFilter self) -> std::string"""
        return _SimpleITK.BilateralImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BilateralImageFilter self) -> std::string"""
        return _SimpleITK.BilateralImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BilateralImageFilter self, Image image1) -> Image"""
        return _SimpleITK.BilateralImageFilter_Execute(self, image1)

# Register BilateralImageFilter in _SimpleITK:
_SimpleITK.BilateralImageFilter_swigregister(BilateralImageFilter)

def Bilateral(image1, domainSigma=4.0, rangeSigma=50.0, numberOfRangeGaussianSamples=100):
    r"""Bilateral(Image image1, double domainSigma=4.0, double rangeSigma=50.0, unsigned int numberOfRangeGaussianSamples=100) -> Image"""
    return _SimpleITK.Bilateral(image1, domainSigma, rangeSigma, numberOfRangeGaussianSamples)
class BinShrinkImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BinShrinkImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BinShrinkImageFilter

    def __init__(self):
        r"""__init__(BinShrinkImageFilter self) -> BinShrinkImageFilter"""
        _SimpleITK.BinShrinkImageFilter_swiginit(self, _SimpleITK.new_BinShrinkImageFilter())

    def SetShrinkFactor(self, s):
        r"""SetShrinkFactor(BinShrinkImageFilter self, unsigned int s)"""
        return _SimpleITK.BinShrinkImageFilter_SetShrinkFactor(self, s)

    def SetShrinkFactors(self, ShrinkFactors):
        r"""SetShrinkFactors(BinShrinkImageFilter self, VectorUInt32 ShrinkFactors)"""
        return _SimpleITK.BinShrinkImageFilter_SetShrinkFactors(self, ShrinkFactors)

    def GetShrinkFactors(self):
        r"""GetShrinkFactors(BinShrinkImageFilter self) -> VectorUInt32"""
        return _SimpleITK.BinShrinkImageFilter_GetShrinkFactors(self)

    def GetName(self):
        r"""GetName(BinShrinkImageFilter self) -> std::string"""
        return _SimpleITK.BinShrinkImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BinShrinkImageFilter self) -> std::string"""
        return _SimpleITK.BinShrinkImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BinShrinkImageFilter self, Image image1) -> Image"""
        return _SimpleITK.BinShrinkImageFilter_Execute(self, image1)

# Register BinShrinkImageFilter in _SimpleITK:
_SimpleITK.BinShrinkImageFilter_swigregister(BinShrinkImageFilter)

def BinShrink(*args, **kwargs):
    r"""BinShrink(Image image1, VectorUInt32 shrinkFactors=std::vector< unsigned int >(3, 1)) -> Image"""
    return _SimpleITK.BinShrink(*args, **kwargs)
class BinaryClosingByReconstructionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BinaryClosingByReconstructionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BinaryClosingByReconstructionImageFilter

    def __init__(self):
        r"""__init__(BinaryClosingByReconstructionImageFilter self) -> BinaryClosingByReconstructionImageFilter"""
        _SimpleITK.BinaryClosingByReconstructionImageFilter_swiginit(self, _SimpleITK.new_BinaryClosingByReconstructionImageFilter())

    def SetKernelRadius(self, *args):
        r"""
        SetKernelRadius(BinaryClosingByReconstructionImageFilter self, VectorUInt32 KernelRadius)
        SetKernelRadius(BinaryClosingByReconstructionImageFilter self, unsigned int value)
        """
        return _SimpleITK.BinaryClosingByReconstructionImageFilter_SetKernelRadius(self, *args)

    def GetKernelRadius(self):
        r"""GetKernelRadius(BinaryClosingByReconstructionImageFilter self) -> VectorUInt32"""
        return _SimpleITK.BinaryClosingByReconstructionImageFilter_GetKernelRadius(self)

    def SetKernelType(self, KernelType):
        r"""SetKernelType(BinaryClosingByReconstructionImageFilter self, slicer_itk::simple::KernelEnum KernelType)"""
        return _SimpleITK.BinaryClosingByReconstructionImageFilter_SetKernelType(self, KernelType)

    def GetKernelType(self):
        r"""GetKernelType(BinaryClosingByReconstructionImageFilter self) -> slicer_itk::simple::KernelEnum"""
        return _SimpleITK.BinaryClosingByReconstructionImageFilter_GetKernelType(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(BinaryClosingByReconstructionImageFilter self, double ForegroundValue)"""
        return _SimpleITK.BinaryClosingByReconstructionImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(BinaryClosingByReconstructionImageFilter self) -> double"""
        return _SimpleITK.BinaryClosingByReconstructionImageFilter_GetForegroundValue(self)

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(BinaryClosingByReconstructionImageFilter self, bool FullyConnected)"""
        return _SimpleITK.BinaryClosingByReconstructionImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(BinaryClosingByReconstructionImageFilter self)"""
        return _SimpleITK.BinaryClosingByReconstructionImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(BinaryClosingByReconstructionImageFilter self)"""
        return _SimpleITK.BinaryClosingByReconstructionImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(BinaryClosingByReconstructionImageFilter self) -> bool"""
        return _SimpleITK.BinaryClosingByReconstructionImageFilter_GetFullyConnected(self)

    def GetName(self):
        r"""GetName(BinaryClosingByReconstructionImageFilter self) -> std::string"""
        return _SimpleITK.BinaryClosingByReconstructionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BinaryClosingByReconstructionImageFilter self) -> std::string"""
        return _SimpleITK.BinaryClosingByReconstructionImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BinaryClosingByReconstructionImageFilter self, Image image1) -> Image"""
        return _SimpleITK.BinaryClosingByReconstructionImageFilter_Execute(self, image1)

# Register BinaryClosingByReconstructionImageFilter in _SimpleITK:
_SimpleITK.BinaryClosingByReconstructionImageFilter_swigregister(BinaryClosingByReconstructionImageFilter)

def BinaryClosingByReconstruction(*args, **kwargs):
    r"""BinaryClosingByReconstruction(Image image1, VectorUInt32 kernelRadius=std::vector< uint32_t >(3, 1), slicer_itk::simple::KernelEnum kernelType=sitkBall, double foregroundValue=1.0, bool fullyConnected=False) -> Image"""
    return _SimpleITK.BinaryClosingByReconstruction(*args, **kwargs)
class BinaryContourImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BinaryContourImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BinaryContourImageFilter

    def __init__(self):
        r"""__init__(BinaryContourImageFilter self) -> BinaryContourImageFilter"""
        _SimpleITK.BinaryContourImageFilter_swiginit(self, _SimpleITK.new_BinaryContourImageFilter())

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(BinaryContourImageFilter self, bool FullyConnected)"""
        return _SimpleITK.BinaryContourImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(BinaryContourImageFilter self)"""
        return _SimpleITK.BinaryContourImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(BinaryContourImageFilter self)"""
        return _SimpleITK.BinaryContourImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(BinaryContourImageFilter self) -> bool"""
        return _SimpleITK.BinaryContourImageFilter_GetFullyConnected(self)

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(BinaryContourImageFilter self, double BackgroundValue)"""
        return _SimpleITK.BinaryContourImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(BinaryContourImageFilter self) -> double"""
        return _SimpleITK.BinaryContourImageFilter_GetBackgroundValue(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(BinaryContourImageFilter self, double ForegroundValue)"""
        return _SimpleITK.BinaryContourImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(BinaryContourImageFilter self) -> double"""
        return _SimpleITK.BinaryContourImageFilter_GetForegroundValue(self)

    def GetName(self):
        r"""GetName(BinaryContourImageFilter self) -> std::string"""
        return _SimpleITK.BinaryContourImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BinaryContourImageFilter self) -> std::string"""
        return _SimpleITK.BinaryContourImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BinaryContourImageFilter self, Image image1) -> Image"""
        return _SimpleITK.BinaryContourImageFilter_Execute(self, image1)

# Register BinaryContourImageFilter in _SimpleITK:
_SimpleITK.BinaryContourImageFilter_swigregister(BinaryContourImageFilter)

def BinaryContour(image1, fullyConnected=False, backgroundValue=0.0, foregroundValue=1.0):
    r"""BinaryContour(Image image1, bool fullyConnected=False, double backgroundValue=0.0, double foregroundValue=1.0) -> Image"""
    return _SimpleITK.BinaryContour(image1, fullyConnected, backgroundValue, foregroundValue)
class BinaryDilateImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BinaryDilateImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BinaryDilateImageFilter

    def __init__(self):
        r"""__init__(BinaryDilateImageFilter self) -> BinaryDilateImageFilter"""
        _SimpleITK.BinaryDilateImageFilter_swiginit(self, _SimpleITK.new_BinaryDilateImageFilter())

    def SetKernelRadius(self, *args):
        r"""
        SetKernelRadius(BinaryDilateImageFilter self, VectorUInt32 KernelRadius)
        SetKernelRadius(BinaryDilateImageFilter self, unsigned int value)
        """
        return _SimpleITK.BinaryDilateImageFilter_SetKernelRadius(self, *args)

    def GetKernelRadius(self):
        r"""GetKernelRadius(BinaryDilateImageFilter self) -> VectorUInt32"""
        return _SimpleITK.BinaryDilateImageFilter_GetKernelRadius(self)

    def SetKernelType(self, KernelType):
        r"""SetKernelType(BinaryDilateImageFilter self, slicer_itk::simple::KernelEnum KernelType)"""
        return _SimpleITK.BinaryDilateImageFilter_SetKernelType(self, KernelType)

    def GetKernelType(self):
        r"""GetKernelType(BinaryDilateImageFilter self) -> slicer_itk::simple::KernelEnum"""
        return _SimpleITK.BinaryDilateImageFilter_GetKernelType(self)

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(BinaryDilateImageFilter self, double BackgroundValue)"""
        return _SimpleITK.BinaryDilateImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(BinaryDilateImageFilter self) -> double"""
        return _SimpleITK.BinaryDilateImageFilter_GetBackgroundValue(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(BinaryDilateImageFilter self, double ForegroundValue)"""
        return _SimpleITK.BinaryDilateImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(BinaryDilateImageFilter self) -> double"""
        return _SimpleITK.BinaryDilateImageFilter_GetForegroundValue(self)

    def SetBoundaryToForeground(self, BoundaryToForeground):
        r"""SetBoundaryToForeground(BinaryDilateImageFilter self, bool BoundaryToForeground)"""
        return _SimpleITK.BinaryDilateImageFilter_SetBoundaryToForeground(self, BoundaryToForeground)

    def BoundaryToForegroundOn(self):
        r"""BoundaryToForegroundOn(BinaryDilateImageFilter self)"""
        return _SimpleITK.BinaryDilateImageFilter_BoundaryToForegroundOn(self)

    def BoundaryToForegroundOff(self):
        r"""BoundaryToForegroundOff(BinaryDilateImageFilter self)"""
        return _SimpleITK.BinaryDilateImageFilter_BoundaryToForegroundOff(self)

    def GetBoundaryToForeground(self):
        r"""GetBoundaryToForeground(BinaryDilateImageFilter self) -> bool"""
        return _SimpleITK.BinaryDilateImageFilter_GetBoundaryToForeground(self)

    def GetName(self):
        r"""GetName(BinaryDilateImageFilter self) -> std::string"""
        return _SimpleITK.BinaryDilateImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BinaryDilateImageFilter self) -> std::string"""
        return _SimpleITK.BinaryDilateImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BinaryDilateImageFilter self, Image image1) -> Image"""
        return _SimpleITK.BinaryDilateImageFilter_Execute(self, image1)

# Register BinaryDilateImageFilter in _SimpleITK:
_SimpleITK.BinaryDilateImageFilter_swigregister(BinaryDilateImageFilter)

def BinaryDilate(*args, **kwargs):
    r"""BinaryDilate(Image image1, VectorUInt32 kernelRadius=std::vector< uint32_t >(3, 1), slicer_itk::simple::KernelEnum kernelType=sitkBall, double backgroundValue=0.0, double foregroundValue=1.0, bool boundaryToForeground=False) -> Image"""
    return _SimpleITK.BinaryDilate(*args, **kwargs)
class BinaryErodeImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BinaryErodeImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BinaryErodeImageFilter

    def __init__(self):
        r"""__init__(BinaryErodeImageFilter self) -> BinaryErodeImageFilter"""
        _SimpleITK.BinaryErodeImageFilter_swiginit(self, _SimpleITK.new_BinaryErodeImageFilter())

    def SetKernelRadius(self, *args):
        r"""
        SetKernelRadius(BinaryErodeImageFilter self, VectorUInt32 KernelRadius)
        SetKernelRadius(BinaryErodeImageFilter self, unsigned int value)
        """
        return _SimpleITK.BinaryErodeImageFilter_SetKernelRadius(self, *args)

    def GetKernelRadius(self):
        r"""GetKernelRadius(BinaryErodeImageFilter self) -> VectorUInt32"""
        return _SimpleITK.BinaryErodeImageFilter_GetKernelRadius(self)

    def SetKernelType(self, KernelType):
        r"""SetKernelType(BinaryErodeImageFilter self, slicer_itk::simple::KernelEnum KernelType)"""
        return _SimpleITK.BinaryErodeImageFilter_SetKernelType(self, KernelType)

    def GetKernelType(self):
        r"""GetKernelType(BinaryErodeImageFilter self) -> slicer_itk::simple::KernelEnum"""
        return _SimpleITK.BinaryErodeImageFilter_GetKernelType(self)

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(BinaryErodeImageFilter self, double BackgroundValue)"""
        return _SimpleITK.BinaryErodeImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(BinaryErodeImageFilter self) -> double"""
        return _SimpleITK.BinaryErodeImageFilter_GetBackgroundValue(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(BinaryErodeImageFilter self, double ForegroundValue)"""
        return _SimpleITK.BinaryErodeImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(BinaryErodeImageFilter self) -> double"""
        return _SimpleITK.BinaryErodeImageFilter_GetForegroundValue(self)

    def SetBoundaryToForeground(self, BoundaryToForeground):
        r"""SetBoundaryToForeground(BinaryErodeImageFilter self, bool BoundaryToForeground)"""
        return _SimpleITK.BinaryErodeImageFilter_SetBoundaryToForeground(self, BoundaryToForeground)

    def BoundaryToForegroundOn(self):
        r"""BoundaryToForegroundOn(BinaryErodeImageFilter self)"""
        return _SimpleITK.BinaryErodeImageFilter_BoundaryToForegroundOn(self)

    def BoundaryToForegroundOff(self):
        r"""BoundaryToForegroundOff(BinaryErodeImageFilter self)"""
        return _SimpleITK.BinaryErodeImageFilter_BoundaryToForegroundOff(self)

    def GetBoundaryToForeground(self):
        r"""GetBoundaryToForeground(BinaryErodeImageFilter self) -> bool"""
        return _SimpleITK.BinaryErodeImageFilter_GetBoundaryToForeground(self)

    def GetName(self):
        r"""GetName(BinaryErodeImageFilter self) -> std::string"""
        return _SimpleITK.BinaryErodeImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BinaryErodeImageFilter self) -> std::string"""
        return _SimpleITK.BinaryErodeImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BinaryErodeImageFilter self, Image image1) -> Image"""
        return _SimpleITK.BinaryErodeImageFilter_Execute(self, image1)

# Register BinaryErodeImageFilter in _SimpleITK:
_SimpleITK.BinaryErodeImageFilter_swigregister(BinaryErodeImageFilter)

def BinaryErode(*args, **kwargs):
    r"""BinaryErode(Image image1, VectorUInt32 kernelRadius=std::vector< uint32_t >(3, 1), slicer_itk::simple::KernelEnum kernelType=sitkBall, double backgroundValue=0.0, double foregroundValue=1.0, bool boundaryToForeground=True) -> Image"""
    return _SimpleITK.BinaryErode(*args, **kwargs)
class BinaryFillholeImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BinaryFillholeImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BinaryFillholeImageFilter

    def __init__(self):
        r"""__init__(BinaryFillholeImageFilter self) -> BinaryFillholeImageFilter"""
        _SimpleITK.BinaryFillholeImageFilter_swiginit(self, _SimpleITK.new_BinaryFillholeImageFilter())

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(BinaryFillholeImageFilter self, bool FullyConnected)"""
        return _SimpleITK.BinaryFillholeImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(BinaryFillholeImageFilter self)"""
        return _SimpleITK.BinaryFillholeImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(BinaryFillholeImageFilter self)"""
        return _SimpleITK.BinaryFillholeImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(BinaryFillholeImageFilter self) -> bool"""
        return _SimpleITK.BinaryFillholeImageFilter_GetFullyConnected(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(BinaryFillholeImageFilter self, double ForegroundValue)"""
        return _SimpleITK.BinaryFillholeImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(BinaryFillholeImageFilter self) -> double"""
        return _SimpleITK.BinaryFillholeImageFilter_GetForegroundValue(self)

    def GetName(self):
        r"""GetName(BinaryFillholeImageFilter self) -> std::string"""
        return _SimpleITK.BinaryFillholeImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BinaryFillholeImageFilter self) -> std::string"""
        return _SimpleITK.BinaryFillholeImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BinaryFillholeImageFilter self, Image image1) -> Image"""
        return _SimpleITK.BinaryFillholeImageFilter_Execute(self, image1)

# Register BinaryFillholeImageFilter in _SimpleITK:
_SimpleITK.BinaryFillholeImageFilter_swigregister(BinaryFillholeImageFilter)

def BinaryFillhole(image1, fullyConnected=False, foregroundValue=1.0):
    r"""BinaryFillhole(Image image1, bool fullyConnected=False, double foregroundValue=1.0) -> Image"""
    return _SimpleITK.BinaryFillhole(image1, fullyConnected, foregroundValue)
class BinaryGrindPeakImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BinaryGrindPeakImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BinaryGrindPeakImageFilter

    def __init__(self):
        r"""__init__(BinaryGrindPeakImageFilter self) -> BinaryGrindPeakImageFilter"""
        _SimpleITK.BinaryGrindPeakImageFilter_swiginit(self, _SimpleITK.new_BinaryGrindPeakImageFilter())

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(BinaryGrindPeakImageFilter self, bool FullyConnected)"""
        return _SimpleITK.BinaryGrindPeakImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(BinaryGrindPeakImageFilter self)"""
        return _SimpleITK.BinaryGrindPeakImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(BinaryGrindPeakImageFilter self)"""
        return _SimpleITK.BinaryGrindPeakImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(BinaryGrindPeakImageFilter self) -> bool"""
        return _SimpleITK.BinaryGrindPeakImageFilter_GetFullyConnected(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(BinaryGrindPeakImageFilter self, double ForegroundValue)"""
        return _SimpleITK.BinaryGrindPeakImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(BinaryGrindPeakImageFilter self) -> double"""
        return _SimpleITK.BinaryGrindPeakImageFilter_GetForegroundValue(self)

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(BinaryGrindPeakImageFilter self, double BackgroundValue)"""
        return _SimpleITK.BinaryGrindPeakImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(BinaryGrindPeakImageFilter self) -> double"""
        return _SimpleITK.BinaryGrindPeakImageFilter_GetBackgroundValue(self)

    def GetName(self):
        r"""GetName(BinaryGrindPeakImageFilter self) -> std::string"""
        return _SimpleITK.BinaryGrindPeakImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BinaryGrindPeakImageFilter self) -> std::string"""
        return _SimpleITK.BinaryGrindPeakImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BinaryGrindPeakImageFilter self, Image image1) -> Image"""
        return _SimpleITK.BinaryGrindPeakImageFilter_Execute(self, image1)

# Register BinaryGrindPeakImageFilter in _SimpleITK:
_SimpleITK.BinaryGrindPeakImageFilter_swigregister(BinaryGrindPeakImageFilter)

def BinaryGrindPeak(image1, fullyConnected=False, foregroundValue=1.0, backgroundValue=0):
    r"""BinaryGrindPeak(Image image1, bool fullyConnected=False, double foregroundValue=1.0, double backgroundValue=0) -> Image"""
    return _SimpleITK.BinaryGrindPeak(image1, fullyConnected, foregroundValue, backgroundValue)
class BinaryImageToLabelMapFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BinaryImageToLabelMapFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BinaryImageToLabelMapFilter

    def __init__(self):
        r"""__init__(BinaryImageToLabelMapFilter self) -> BinaryImageToLabelMapFilter"""
        _SimpleITK.BinaryImageToLabelMapFilter_swiginit(self, _SimpleITK.new_BinaryImageToLabelMapFilter())

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(BinaryImageToLabelMapFilter self, bool FullyConnected)"""
        return _SimpleITK.BinaryImageToLabelMapFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(BinaryImageToLabelMapFilter self)"""
        return _SimpleITK.BinaryImageToLabelMapFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(BinaryImageToLabelMapFilter self)"""
        return _SimpleITK.BinaryImageToLabelMapFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(BinaryImageToLabelMapFilter self) -> bool"""
        return _SimpleITK.BinaryImageToLabelMapFilter_GetFullyConnected(self)

    def SetInputForegroundValue(self, InputForegroundValue):
        r"""SetInputForegroundValue(BinaryImageToLabelMapFilter self, double InputForegroundValue)"""
        return _SimpleITK.BinaryImageToLabelMapFilter_SetInputForegroundValue(self, InputForegroundValue)

    def GetInputForegroundValue(self):
        r"""GetInputForegroundValue(BinaryImageToLabelMapFilter self) -> double"""
        return _SimpleITK.BinaryImageToLabelMapFilter_GetInputForegroundValue(self)

    def SetOutputBackgroundValue(self, OutputBackgroundValue):
        r"""SetOutputBackgroundValue(BinaryImageToLabelMapFilter self, double OutputBackgroundValue)"""
        return _SimpleITK.BinaryImageToLabelMapFilter_SetOutputBackgroundValue(self, OutputBackgroundValue)

    def GetOutputBackgroundValue(self):
        r"""GetOutputBackgroundValue(BinaryImageToLabelMapFilter self) -> double"""
        return _SimpleITK.BinaryImageToLabelMapFilter_GetOutputBackgroundValue(self)

    def GetNumberOfObjects(self):
        r"""GetNumberOfObjects(BinaryImageToLabelMapFilter self) -> uint64_t"""
        return _SimpleITK.BinaryImageToLabelMapFilter_GetNumberOfObjects(self)

    def GetName(self):
        r"""GetName(BinaryImageToLabelMapFilter self) -> std::string"""
        return _SimpleITK.BinaryImageToLabelMapFilter_GetName(self)

    def __str__(self):
        r"""__str__(BinaryImageToLabelMapFilter self) -> std::string"""
        return _SimpleITK.BinaryImageToLabelMapFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BinaryImageToLabelMapFilter self, Image image1) -> Image"""
        return _SimpleITK.BinaryImageToLabelMapFilter_Execute(self, image1)

# Register BinaryImageToLabelMapFilter in _SimpleITK:
_SimpleITK.BinaryImageToLabelMapFilter_swigregister(BinaryImageToLabelMapFilter)

def BinaryImageToLabelMap(image1, fullyConnected=False, inputForegroundValue=1.0, outputBackgroundValue=0.0):
    r"""BinaryImageToLabelMap(Image image1, bool fullyConnected=False, double inputForegroundValue=1.0, double outputBackgroundValue=0.0) -> Image"""
    return _SimpleITK.BinaryImageToLabelMap(image1, fullyConnected, inputForegroundValue, outputBackgroundValue)
class BinaryMagnitudeImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BinaryMagnitudeImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BinaryMagnitudeImageFilter

    def __init__(self):
        r"""__init__(BinaryMagnitudeImageFilter self) -> BinaryMagnitudeImageFilter"""
        _SimpleITK.BinaryMagnitudeImageFilter_swiginit(self, _SimpleITK.new_BinaryMagnitudeImageFilter())

    def GetName(self):
        r"""GetName(BinaryMagnitudeImageFilter self) -> std::string"""
        return _SimpleITK.BinaryMagnitudeImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BinaryMagnitudeImageFilter self) -> std::string"""
        return _SimpleITK.BinaryMagnitudeImageFilter___str__(self)

    def Execute(self, image1, image2):
        r"""Execute(BinaryMagnitudeImageFilter self, Image image1, Image image2) -> Image"""
        return _SimpleITK.BinaryMagnitudeImageFilter_Execute(self, image1, image2)

# Register BinaryMagnitudeImageFilter in _SimpleITK:
_SimpleITK.BinaryMagnitudeImageFilter_swigregister(BinaryMagnitudeImageFilter)

def BinaryMagnitude(image1, image2):
    r"""BinaryMagnitude(Image image1, Image image2) -> Image"""
    return _SimpleITK.BinaryMagnitude(image1, image2)
class BinaryMedianImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BinaryMedianImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BinaryMedianImageFilter

    def __init__(self):
        r"""__init__(BinaryMedianImageFilter self) -> BinaryMedianImageFilter"""
        _SimpleITK.BinaryMedianImageFilter_swiginit(self, _SimpleITK.new_BinaryMedianImageFilter())

    def SetRadius(self, *args):
        r"""
        SetRadius(BinaryMedianImageFilter self, VectorUInt32 Radius)
        SetRadius(BinaryMedianImageFilter self, unsigned int value)
        """
        return _SimpleITK.BinaryMedianImageFilter_SetRadius(self, *args)

    def GetRadius(self):
        r"""GetRadius(BinaryMedianImageFilter self) -> VectorUInt32"""
        return _SimpleITK.BinaryMedianImageFilter_GetRadius(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(BinaryMedianImageFilter self, double ForegroundValue)"""
        return _SimpleITK.BinaryMedianImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(BinaryMedianImageFilter self) -> double"""
        return _SimpleITK.BinaryMedianImageFilter_GetForegroundValue(self)

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(BinaryMedianImageFilter self, double BackgroundValue)"""
        return _SimpleITK.BinaryMedianImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(BinaryMedianImageFilter self) -> double"""
        return _SimpleITK.BinaryMedianImageFilter_GetBackgroundValue(self)

    def GetName(self):
        r"""GetName(BinaryMedianImageFilter self) -> std::string"""
        return _SimpleITK.BinaryMedianImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BinaryMedianImageFilter self) -> std::string"""
        return _SimpleITK.BinaryMedianImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BinaryMedianImageFilter self, Image image1) -> Image"""
        return _SimpleITK.BinaryMedianImageFilter_Execute(self, image1)

# Register BinaryMedianImageFilter in _SimpleITK:
_SimpleITK.BinaryMedianImageFilter_swigregister(BinaryMedianImageFilter)

def BinaryMedian(*args, **kwargs):
    r"""BinaryMedian(Image image1, VectorUInt32 radius=std::vector< unsigned int >(3, 1), double foregroundValue=1.0, double backgroundValue=0.0) -> Image"""
    return _SimpleITK.BinaryMedian(*args, **kwargs)
class BinaryMinMaxCurvatureFlowImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BinaryMinMaxCurvatureFlowImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BinaryMinMaxCurvatureFlowImageFilter

    def __init__(self):
        r"""__init__(BinaryMinMaxCurvatureFlowImageFilter self) -> BinaryMinMaxCurvatureFlowImageFilter"""
        _SimpleITK.BinaryMinMaxCurvatureFlowImageFilter_swiginit(self, _SimpleITK.new_BinaryMinMaxCurvatureFlowImageFilter())

    def SetTimeStep(self, TimeStep):
        r"""SetTimeStep(BinaryMinMaxCurvatureFlowImageFilter self, double TimeStep)"""
        return _SimpleITK.BinaryMinMaxCurvatureFlowImageFilter_SetTimeStep(self, TimeStep)

    def GetTimeStep(self):
        r"""GetTimeStep(BinaryMinMaxCurvatureFlowImageFilter self) -> double"""
        return _SimpleITK.BinaryMinMaxCurvatureFlowImageFilter_GetTimeStep(self)

    def SetNumberOfIterations(self, NumberOfIterations):
        r"""SetNumberOfIterations(BinaryMinMaxCurvatureFlowImageFilter self, uint32_t NumberOfIterations)"""
        return _SimpleITK.BinaryMinMaxCurvatureFlowImageFilter_SetNumberOfIterations(self, NumberOfIterations)

    def GetNumberOfIterations(self):
        r"""GetNumberOfIterations(BinaryMinMaxCurvatureFlowImageFilter self) -> uint32_t"""
        return _SimpleITK.BinaryMinMaxCurvatureFlowImageFilter_GetNumberOfIterations(self)

    def SetStencilRadius(self, StencilRadius):
        r"""SetStencilRadius(BinaryMinMaxCurvatureFlowImageFilter self, int StencilRadius)"""
        return _SimpleITK.BinaryMinMaxCurvatureFlowImageFilter_SetStencilRadius(self, StencilRadius)

    def GetStencilRadius(self):
        r"""GetStencilRadius(BinaryMinMaxCurvatureFlowImageFilter self) -> int"""
        return _SimpleITK.BinaryMinMaxCurvatureFlowImageFilter_GetStencilRadius(self)

    def SetThreshold(self, Threshold):
        r"""SetThreshold(BinaryMinMaxCurvatureFlowImageFilter self, double Threshold)"""
        return _SimpleITK.BinaryMinMaxCurvatureFlowImageFilter_SetThreshold(self, Threshold)

    def GetThreshold(self):
        r"""GetThreshold(BinaryMinMaxCurvatureFlowImageFilter self) -> double"""
        return _SimpleITK.BinaryMinMaxCurvatureFlowImageFilter_GetThreshold(self)

    def GetName(self):
        r"""GetName(BinaryMinMaxCurvatureFlowImageFilter self) -> std::string"""
        return _SimpleITK.BinaryMinMaxCurvatureFlowImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BinaryMinMaxCurvatureFlowImageFilter self) -> std::string"""
        return _SimpleITK.BinaryMinMaxCurvatureFlowImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BinaryMinMaxCurvatureFlowImageFilter self, Image image1) -> Image"""
        return _SimpleITK.BinaryMinMaxCurvatureFlowImageFilter_Execute(self, image1)

# Register BinaryMinMaxCurvatureFlowImageFilter in _SimpleITK:
_SimpleITK.BinaryMinMaxCurvatureFlowImageFilter_swigregister(BinaryMinMaxCurvatureFlowImageFilter)

def BinaryMinMaxCurvatureFlow(image1, timeStep=0.05, numberOfIterations=5, stencilRadius=2, threshold=0.0):
    r"""BinaryMinMaxCurvatureFlow(Image image1, double timeStep=0.05, uint32_t numberOfIterations=5, int stencilRadius=2, double threshold=0.0) -> Image"""
    return _SimpleITK.BinaryMinMaxCurvatureFlow(image1, timeStep, numberOfIterations, stencilRadius, threshold)
class BinaryMorphologicalClosingImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BinaryMorphologicalClosingImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BinaryMorphologicalClosingImageFilter

    def __init__(self):
        r"""__init__(BinaryMorphologicalClosingImageFilter self) -> BinaryMorphologicalClosingImageFilter"""
        _SimpleITK.BinaryMorphologicalClosingImageFilter_swiginit(self, _SimpleITK.new_BinaryMorphologicalClosingImageFilter())

    def SetKernelRadius(self, *args):
        r"""
        SetKernelRadius(BinaryMorphologicalClosingImageFilter self, VectorUInt32 KernelRadius)
        SetKernelRadius(BinaryMorphologicalClosingImageFilter self, unsigned int value)
        """
        return _SimpleITK.BinaryMorphologicalClosingImageFilter_SetKernelRadius(self, *args)

    def GetKernelRadius(self):
        r"""GetKernelRadius(BinaryMorphologicalClosingImageFilter self) -> VectorUInt32"""
        return _SimpleITK.BinaryMorphologicalClosingImageFilter_GetKernelRadius(self)

    def SetKernelType(self, KernelType):
        r"""SetKernelType(BinaryMorphologicalClosingImageFilter self, slicer_itk::simple::KernelEnum KernelType)"""
        return _SimpleITK.BinaryMorphologicalClosingImageFilter_SetKernelType(self, KernelType)

    def GetKernelType(self):
        r"""GetKernelType(BinaryMorphologicalClosingImageFilter self) -> slicer_itk::simple::KernelEnum"""
        return _SimpleITK.BinaryMorphologicalClosingImageFilter_GetKernelType(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(BinaryMorphologicalClosingImageFilter self, double ForegroundValue)"""
        return _SimpleITK.BinaryMorphologicalClosingImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(BinaryMorphologicalClosingImageFilter self) -> double"""
        return _SimpleITK.BinaryMorphologicalClosingImageFilter_GetForegroundValue(self)

    def SetSafeBorder(self, SafeBorder):
        r"""SetSafeBorder(BinaryMorphologicalClosingImageFilter self, bool SafeBorder)"""
        return _SimpleITK.BinaryMorphologicalClosingImageFilter_SetSafeBorder(self, SafeBorder)

    def SafeBorderOn(self):
        r"""SafeBorderOn(BinaryMorphologicalClosingImageFilter self)"""
        return _SimpleITK.BinaryMorphologicalClosingImageFilter_SafeBorderOn(self)

    def SafeBorderOff(self):
        r"""SafeBorderOff(BinaryMorphologicalClosingImageFilter self)"""
        return _SimpleITK.BinaryMorphologicalClosingImageFilter_SafeBorderOff(self)

    def GetSafeBorder(self):
        r"""GetSafeBorder(BinaryMorphologicalClosingImageFilter self) -> bool"""
        return _SimpleITK.BinaryMorphologicalClosingImageFilter_GetSafeBorder(self)

    def GetName(self):
        r"""GetName(BinaryMorphologicalClosingImageFilter self) -> std::string"""
        return _SimpleITK.BinaryMorphologicalClosingImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BinaryMorphologicalClosingImageFilter self) -> std::string"""
        return _SimpleITK.BinaryMorphologicalClosingImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BinaryMorphologicalClosingImageFilter self, Image image1) -> Image"""
        return _SimpleITK.BinaryMorphologicalClosingImageFilter_Execute(self, image1)

# Register BinaryMorphologicalClosingImageFilter in _SimpleITK:
_SimpleITK.BinaryMorphologicalClosingImageFilter_swigregister(BinaryMorphologicalClosingImageFilter)

def BinaryMorphologicalClosing(*args, **kwargs):
    r"""BinaryMorphologicalClosing(Image image1, VectorUInt32 kernelRadius=std::vector< uint32_t >(3, 1), slicer_itk::simple::KernelEnum kernelType=sitkBall, double foregroundValue=1.0, bool safeBorder=True) -> Image"""
    return _SimpleITK.BinaryMorphologicalClosing(*args, **kwargs)
class BinaryMorphologicalOpeningImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BinaryMorphologicalOpeningImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BinaryMorphologicalOpeningImageFilter

    def __init__(self):
        r"""__init__(BinaryMorphologicalOpeningImageFilter self) -> BinaryMorphologicalOpeningImageFilter"""
        _SimpleITK.BinaryMorphologicalOpeningImageFilter_swiginit(self, _SimpleITK.new_BinaryMorphologicalOpeningImageFilter())

    def SetKernelRadius(self, *args):
        r"""
        SetKernelRadius(BinaryMorphologicalOpeningImageFilter self, VectorUInt32 KernelRadius)
        SetKernelRadius(BinaryMorphologicalOpeningImageFilter self, unsigned int value)
        """
        return _SimpleITK.BinaryMorphologicalOpeningImageFilter_SetKernelRadius(self, *args)

    def GetKernelRadius(self):
        r"""GetKernelRadius(BinaryMorphologicalOpeningImageFilter self) -> VectorUInt32"""
        return _SimpleITK.BinaryMorphologicalOpeningImageFilter_GetKernelRadius(self)

    def SetKernelType(self, KernelType):
        r"""SetKernelType(BinaryMorphologicalOpeningImageFilter self, slicer_itk::simple::KernelEnum KernelType)"""
        return _SimpleITK.BinaryMorphologicalOpeningImageFilter_SetKernelType(self, KernelType)

    def GetKernelType(self):
        r"""GetKernelType(BinaryMorphologicalOpeningImageFilter self) -> slicer_itk::simple::KernelEnum"""
        return _SimpleITK.BinaryMorphologicalOpeningImageFilter_GetKernelType(self)

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(BinaryMorphologicalOpeningImageFilter self, double BackgroundValue)"""
        return _SimpleITK.BinaryMorphologicalOpeningImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(BinaryMorphologicalOpeningImageFilter self) -> double"""
        return _SimpleITK.BinaryMorphologicalOpeningImageFilter_GetBackgroundValue(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(BinaryMorphologicalOpeningImageFilter self, double ForegroundValue)"""
        return _SimpleITK.BinaryMorphologicalOpeningImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(BinaryMorphologicalOpeningImageFilter self) -> double"""
        return _SimpleITK.BinaryMorphologicalOpeningImageFilter_GetForegroundValue(self)

    def GetName(self):
        r"""GetName(BinaryMorphologicalOpeningImageFilter self) -> std::string"""
        return _SimpleITK.BinaryMorphologicalOpeningImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BinaryMorphologicalOpeningImageFilter self) -> std::string"""
        return _SimpleITK.BinaryMorphologicalOpeningImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BinaryMorphologicalOpeningImageFilter self, Image image1) -> Image"""
        return _SimpleITK.BinaryMorphologicalOpeningImageFilter_Execute(self, image1)

# Register BinaryMorphologicalOpeningImageFilter in _SimpleITK:
_SimpleITK.BinaryMorphologicalOpeningImageFilter_swigregister(BinaryMorphologicalOpeningImageFilter)

def BinaryMorphologicalOpening(*args, **kwargs):
    r"""BinaryMorphologicalOpening(Image image1, VectorUInt32 kernelRadius=std::vector< uint32_t >(3, 1), slicer_itk::simple::KernelEnum kernelType=sitkBall, double backgroundValue=0.0, double foregroundValue=1.0) -> Image"""
    return _SimpleITK.BinaryMorphologicalOpening(*args, **kwargs)
class BinaryNotImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BinaryNotImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BinaryNotImageFilter

    def __init__(self):
        r"""__init__(BinaryNotImageFilter self) -> BinaryNotImageFilter"""
        _SimpleITK.BinaryNotImageFilter_swiginit(self, _SimpleITK.new_BinaryNotImageFilter())

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(BinaryNotImageFilter self, double ForegroundValue)"""
        return _SimpleITK.BinaryNotImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(BinaryNotImageFilter self) -> double"""
        return _SimpleITK.BinaryNotImageFilter_GetForegroundValue(self)

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(BinaryNotImageFilter self, double BackgroundValue)"""
        return _SimpleITK.BinaryNotImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(BinaryNotImageFilter self) -> double"""
        return _SimpleITK.BinaryNotImageFilter_GetBackgroundValue(self)

    def GetName(self):
        r"""GetName(BinaryNotImageFilter self) -> std::string"""
        return _SimpleITK.BinaryNotImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BinaryNotImageFilter self) -> std::string"""
        return _SimpleITK.BinaryNotImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BinaryNotImageFilter self, Image image1) -> Image"""
        return _SimpleITK.BinaryNotImageFilter_Execute(self, image1)

# Register BinaryNotImageFilter in _SimpleITK:
_SimpleITK.BinaryNotImageFilter_swigregister(BinaryNotImageFilter)

def BinaryNot(image1, foregroundValue=1.0, backgroundValue=0.0):
    r"""BinaryNot(Image image1, double foregroundValue=1.0, double backgroundValue=0.0) -> Image"""
    return _SimpleITK.BinaryNot(image1, foregroundValue, backgroundValue)
class BinaryOpeningByReconstructionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BinaryOpeningByReconstructionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BinaryOpeningByReconstructionImageFilter

    def __init__(self):
        r"""__init__(BinaryOpeningByReconstructionImageFilter self) -> BinaryOpeningByReconstructionImageFilter"""
        _SimpleITK.BinaryOpeningByReconstructionImageFilter_swiginit(self, _SimpleITK.new_BinaryOpeningByReconstructionImageFilter())

    def SetKernelRadius(self, *args):
        r"""
        SetKernelRadius(BinaryOpeningByReconstructionImageFilter self, VectorUInt32 KernelRadius)
        SetKernelRadius(BinaryOpeningByReconstructionImageFilter self, unsigned int value)
        """
        return _SimpleITK.BinaryOpeningByReconstructionImageFilter_SetKernelRadius(self, *args)

    def GetKernelRadius(self):
        r"""GetKernelRadius(BinaryOpeningByReconstructionImageFilter self) -> VectorUInt32"""
        return _SimpleITK.BinaryOpeningByReconstructionImageFilter_GetKernelRadius(self)

    def SetKernelType(self, KernelType):
        r"""SetKernelType(BinaryOpeningByReconstructionImageFilter self, slicer_itk::simple::KernelEnum KernelType)"""
        return _SimpleITK.BinaryOpeningByReconstructionImageFilter_SetKernelType(self, KernelType)

    def GetKernelType(self):
        r"""GetKernelType(BinaryOpeningByReconstructionImageFilter self) -> slicer_itk::simple::KernelEnum"""
        return _SimpleITK.BinaryOpeningByReconstructionImageFilter_GetKernelType(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(BinaryOpeningByReconstructionImageFilter self, double ForegroundValue)"""
        return _SimpleITK.BinaryOpeningByReconstructionImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(BinaryOpeningByReconstructionImageFilter self) -> double"""
        return _SimpleITK.BinaryOpeningByReconstructionImageFilter_GetForegroundValue(self)

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(BinaryOpeningByReconstructionImageFilter self, double BackgroundValue)"""
        return _SimpleITK.BinaryOpeningByReconstructionImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(BinaryOpeningByReconstructionImageFilter self) -> double"""
        return _SimpleITK.BinaryOpeningByReconstructionImageFilter_GetBackgroundValue(self)

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(BinaryOpeningByReconstructionImageFilter self, bool FullyConnected)"""
        return _SimpleITK.BinaryOpeningByReconstructionImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(BinaryOpeningByReconstructionImageFilter self)"""
        return _SimpleITK.BinaryOpeningByReconstructionImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(BinaryOpeningByReconstructionImageFilter self)"""
        return _SimpleITK.BinaryOpeningByReconstructionImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(BinaryOpeningByReconstructionImageFilter self) -> bool"""
        return _SimpleITK.BinaryOpeningByReconstructionImageFilter_GetFullyConnected(self)

    def GetName(self):
        r"""GetName(BinaryOpeningByReconstructionImageFilter self) -> std::string"""
        return _SimpleITK.BinaryOpeningByReconstructionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BinaryOpeningByReconstructionImageFilter self) -> std::string"""
        return _SimpleITK.BinaryOpeningByReconstructionImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BinaryOpeningByReconstructionImageFilter self, Image image1) -> Image"""
        return _SimpleITK.BinaryOpeningByReconstructionImageFilter_Execute(self, image1)

# Register BinaryOpeningByReconstructionImageFilter in _SimpleITK:
_SimpleITK.BinaryOpeningByReconstructionImageFilter_swigregister(BinaryOpeningByReconstructionImageFilter)

def BinaryOpeningByReconstruction(*args, **kwargs):
    r"""BinaryOpeningByReconstruction(Image image1, VectorUInt32 kernelRadius=std::vector< uint32_t >(3, 1), slicer_itk::simple::KernelEnum kernelType=sitkBall, double foregroundValue=1.0, double backgroundValue=0.0, bool fullyConnected=False) -> Image"""
    return _SimpleITK.BinaryOpeningByReconstruction(*args, **kwargs)
class BinaryProjectionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BinaryProjectionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BinaryProjectionImageFilter

    def __init__(self):
        r"""__init__(BinaryProjectionImageFilter self) -> BinaryProjectionImageFilter"""
        _SimpleITK.BinaryProjectionImageFilter_swiginit(self, _SimpleITK.new_BinaryProjectionImageFilter())

    def SetProjectionDimension(self, ProjectionDimension):
        r"""SetProjectionDimension(BinaryProjectionImageFilter self, unsigned int ProjectionDimension)"""
        return _SimpleITK.BinaryProjectionImageFilter_SetProjectionDimension(self, ProjectionDimension)

    def GetProjectionDimension(self):
        r"""GetProjectionDimension(BinaryProjectionImageFilter self) -> unsigned int"""
        return _SimpleITK.BinaryProjectionImageFilter_GetProjectionDimension(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(BinaryProjectionImageFilter self, double ForegroundValue)"""
        return _SimpleITK.BinaryProjectionImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(BinaryProjectionImageFilter self) -> double"""
        return _SimpleITK.BinaryProjectionImageFilter_GetForegroundValue(self)

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(BinaryProjectionImageFilter self, double BackgroundValue)"""
        return _SimpleITK.BinaryProjectionImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(BinaryProjectionImageFilter self) -> double"""
        return _SimpleITK.BinaryProjectionImageFilter_GetBackgroundValue(self)

    def GetName(self):
        r"""GetName(BinaryProjectionImageFilter self) -> std::string"""
        return _SimpleITK.BinaryProjectionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BinaryProjectionImageFilter self) -> std::string"""
        return _SimpleITK.BinaryProjectionImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BinaryProjectionImageFilter self, Image image1) -> Image"""
        return _SimpleITK.BinaryProjectionImageFilter_Execute(self, image1)

# Register BinaryProjectionImageFilter in _SimpleITK:
_SimpleITK.BinaryProjectionImageFilter_swigregister(BinaryProjectionImageFilter)

def BinaryProjection(image1, projectionDimension=0, foregroundValue=1.0, backgroundValue=0.0):
    r"""BinaryProjection(Image image1, unsigned int projectionDimension=0, double foregroundValue=1.0, double backgroundValue=0.0) -> Image"""
    return _SimpleITK.BinaryProjection(image1, projectionDimension, foregroundValue, backgroundValue)
class BinaryPruningImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BinaryPruningImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BinaryPruningImageFilter

    def __init__(self):
        r"""__init__(BinaryPruningImageFilter self) -> BinaryPruningImageFilter"""
        _SimpleITK.BinaryPruningImageFilter_swiginit(self, _SimpleITK.new_BinaryPruningImageFilter())

    def SetIteration(self, Iteration):
        r"""SetIteration(BinaryPruningImageFilter self, uint32_t Iteration)"""
        return _SimpleITK.BinaryPruningImageFilter_SetIteration(self, Iteration)

    def GetIteration(self):
        r"""GetIteration(BinaryPruningImageFilter self) -> uint32_t"""
        return _SimpleITK.BinaryPruningImageFilter_GetIteration(self)

    def GetName(self):
        r"""GetName(BinaryPruningImageFilter self) -> std::string"""
        return _SimpleITK.BinaryPruningImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BinaryPruningImageFilter self) -> std::string"""
        return _SimpleITK.BinaryPruningImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BinaryPruningImageFilter self, Image image1) -> Image"""
        return _SimpleITK.BinaryPruningImageFilter_Execute(self, image1)

# Register BinaryPruningImageFilter in _SimpleITK:
_SimpleITK.BinaryPruningImageFilter_swigregister(BinaryPruningImageFilter)

def BinaryPruning(image1, iteration=3):
    r"""BinaryPruning(Image image1, uint32_t iteration=3) -> Image"""
    return _SimpleITK.BinaryPruning(image1, iteration)
class BinaryReconstructionByDilationImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BinaryReconstructionByDilationImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BinaryReconstructionByDilationImageFilter

    def __init__(self):
        r"""__init__(BinaryReconstructionByDilationImageFilter self) -> BinaryReconstructionByDilationImageFilter"""
        _SimpleITK.BinaryReconstructionByDilationImageFilter_swiginit(self, _SimpleITK.new_BinaryReconstructionByDilationImageFilter())

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(BinaryReconstructionByDilationImageFilter self, double BackgroundValue)"""
        return _SimpleITK.BinaryReconstructionByDilationImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(BinaryReconstructionByDilationImageFilter self) -> double"""
        return _SimpleITK.BinaryReconstructionByDilationImageFilter_GetBackgroundValue(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(BinaryReconstructionByDilationImageFilter self, double ForegroundValue)"""
        return _SimpleITK.BinaryReconstructionByDilationImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(BinaryReconstructionByDilationImageFilter self) -> double"""
        return _SimpleITK.BinaryReconstructionByDilationImageFilter_GetForegroundValue(self)

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(BinaryReconstructionByDilationImageFilter self, bool FullyConnected)"""
        return _SimpleITK.BinaryReconstructionByDilationImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(BinaryReconstructionByDilationImageFilter self)"""
        return _SimpleITK.BinaryReconstructionByDilationImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(BinaryReconstructionByDilationImageFilter self)"""
        return _SimpleITK.BinaryReconstructionByDilationImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(BinaryReconstructionByDilationImageFilter self) -> bool"""
        return _SimpleITK.BinaryReconstructionByDilationImageFilter_GetFullyConnected(self)

    def GetName(self):
        r"""GetName(BinaryReconstructionByDilationImageFilter self) -> std::string"""
        return _SimpleITK.BinaryReconstructionByDilationImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BinaryReconstructionByDilationImageFilter self) -> std::string"""
        return _SimpleITK.BinaryReconstructionByDilationImageFilter___str__(self)

    def Execute(self, markerImage, maskImage):
        r"""Execute(BinaryReconstructionByDilationImageFilter self, Image markerImage, Image maskImage) -> Image"""
        return _SimpleITK.BinaryReconstructionByDilationImageFilter_Execute(self, markerImage, maskImage)

# Register BinaryReconstructionByDilationImageFilter in _SimpleITK:
_SimpleITK.BinaryReconstructionByDilationImageFilter_swigregister(BinaryReconstructionByDilationImageFilter)

def BinaryReconstructionByDilation(markerImage, maskImage, backgroundValue=0.0, foregroundValue=1.0, fullyConnected=False):
    r"""BinaryReconstructionByDilation(Image markerImage, Image maskImage, double backgroundValue=0.0, double foregroundValue=1.0, bool fullyConnected=False) -> Image"""
    return _SimpleITK.BinaryReconstructionByDilation(markerImage, maskImage, backgroundValue, foregroundValue, fullyConnected)
class BinaryReconstructionByErosionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BinaryReconstructionByErosionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BinaryReconstructionByErosionImageFilter

    def __init__(self):
        r"""__init__(BinaryReconstructionByErosionImageFilter self) -> BinaryReconstructionByErosionImageFilter"""
        _SimpleITK.BinaryReconstructionByErosionImageFilter_swiginit(self, _SimpleITK.new_BinaryReconstructionByErosionImageFilter())

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(BinaryReconstructionByErosionImageFilter self, double BackgroundValue)"""
        return _SimpleITK.BinaryReconstructionByErosionImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(BinaryReconstructionByErosionImageFilter self) -> double"""
        return _SimpleITK.BinaryReconstructionByErosionImageFilter_GetBackgroundValue(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(BinaryReconstructionByErosionImageFilter self, double ForegroundValue)"""
        return _SimpleITK.BinaryReconstructionByErosionImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(BinaryReconstructionByErosionImageFilter self) -> double"""
        return _SimpleITK.BinaryReconstructionByErosionImageFilter_GetForegroundValue(self)

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(BinaryReconstructionByErosionImageFilter self, bool FullyConnected)"""
        return _SimpleITK.BinaryReconstructionByErosionImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(BinaryReconstructionByErosionImageFilter self)"""
        return _SimpleITK.BinaryReconstructionByErosionImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(BinaryReconstructionByErosionImageFilter self)"""
        return _SimpleITK.BinaryReconstructionByErosionImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(BinaryReconstructionByErosionImageFilter self) -> bool"""
        return _SimpleITK.BinaryReconstructionByErosionImageFilter_GetFullyConnected(self)

    def GetName(self):
        r"""GetName(BinaryReconstructionByErosionImageFilter self) -> std::string"""
        return _SimpleITK.BinaryReconstructionByErosionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BinaryReconstructionByErosionImageFilter self) -> std::string"""
        return _SimpleITK.BinaryReconstructionByErosionImageFilter___str__(self)

    def Execute(self, markerImage, maskImage):
        r"""Execute(BinaryReconstructionByErosionImageFilter self, Image markerImage, Image maskImage) -> Image"""
        return _SimpleITK.BinaryReconstructionByErosionImageFilter_Execute(self, markerImage, maskImage)

# Register BinaryReconstructionByErosionImageFilter in _SimpleITK:
_SimpleITK.BinaryReconstructionByErosionImageFilter_swigregister(BinaryReconstructionByErosionImageFilter)

def BinaryReconstructionByErosion(markerImage, maskImage, backgroundValue=0.0, foregroundValue=1.0, fullyConnected=False):
    r"""BinaryReconstructionByErosion(Image markerImage, Image maskImage, double backgroundValue=0.0, double foregroundValue=1.0, bool fullyConnected=False) -> Image"""
    return _SimpleITK.BinaryReconstructionByErosion(markerImage, maskImage, backgroundValue, foregroundValue, fullyConnected)
class BinaryThinningImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BinaryThinningImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BinaryThinningImageFilter

    def __init__(self):
        r"""__init__(BinaryThinningImageFilter self) -> BinaryThinningImageFilter"""
        _SimpleITK.BinaryThinningImageFilter_swiginit(self, _SimpleITK.new_BinaryThinningImageFilter())

    def GetName(self):
        r"""GetName(BinaryThinningImageFilter self) -> std::string"""
        return _SimpleITK.BinaryThinningImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BinaryThinningImageFilter self) -> std::string"""
        return _SimpleITK.BinaryThinningImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BinaryThinningImageFilter self, Image image1) -> Image"""
        return _SimpleITK.BinaryThinningImageFilter_Execute(self, image1)

# Register BinaryThinningImageFilter in _SimpleITK:
_SimpleITK.BinaryThinningImageFilter_swigregister(BinaryThinningImageFilter)

def BinaryThinning(image1):
    r"""BinaryThinning(Image image1) -> Image"""
    return _SimpleITK.BinaryThinning(image1)
class BinaryThresholdImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BinaryThresholdImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BinaryThresholdImageFilter

    def __init__(self):
        r"""__init__(BinaryThresholdImageFilter self) -> BinaryThresholdImageFilter"""
        _SimpleITK.BinaryThresholdImageFilter_swiginit(self, _SimpleITK.new_BinaryThresholdImageFilter())

    def SetLowerThreshold(self, LowerThreshold):
        r"""SetLowerThreshold(BinaryThresholdImageFilter self, double LowerThreshold)"""
        return _SimpleITK.BinaryThresholdImageFilter_SetLowerThreshold(self, LowerThreshold)

    def GetLowerThreshold(self):
        r"""GetLowerThreshold(BinaryThresholdImageFilter self) -> double"""
        return _SimpleITK.BinaryThresholdImageFilter_GetLowerThreshold(self)

    def SetUpperThreshold(self, UpperThreshold):
        r"""SetUpperThreshold(BinaryThresholdImageFilter self, double UpperThreshold)"""
        return _SimpleITK.BinaryThresholdImageFilter_SetUpperThreshold(self, UpperThreshold)

    def GetUpperThreshold(self):
        r"""GetUpperThreshold(BinaryThresholdImageFilter self) -> double"""
        return _SimpleITK.BinaryThresholdImageFilter_GetUpperThreshold(self)

    def SetInsideValue(self, InsideValue):
        r"""SetInsideValue(BinaryThresholdImageFilter self, uint8_t InsideValue)"""
        return _SimpleITK.BinaryThresholdImageFilter_SetInsideValue(self, InsideValue)

    def GetInsideValue(self):
        r"""GetInsideValue(BinaryThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.BinaryThresholdImageFilter_GetInsideValue(self)

    def SetOutsideValue(self, OutsideValue):
        r"""SetOutsideValue(BinaryThresholdImageFilter self, uint8_t OutsideValue)"""
        return _SimpleITK.BinaryThresholdImageFilter_SetOutsideValue(self, OutsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(BinaryThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.BinaryThresholdImageFilter_GetOutsideValue(self)

    def GetName(self):
        r"""GetName(BinaryThresholdImageFilter self) -> std::string"""
        return _SimpleITK.BinaryThresholdImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BinaryThresholdImageFilter self) -> std::string"""
        return _SimpleITK.BinaryThresholdImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BinaryThresholdImageFilter self, Image image1) -> Image"""
        return _SimpleITK.BinaryThresholdImageFilter_Execute(self, image1)

# Register BinaryThresholdImageFilter in _SimpleITK:
_SimpleITK.BinaryThresholdImageFilter_swigregister(BinaryThresholdImageFilter)

def BinaryThreshold(image1, lowerThreshold=0.0, upperThreshold=255.0, insideValue=1, outsideValue=0):
    r"""BinaryThreshold(Image image1, double lowerThreshold=0.0, double upperThreshold=255.0, uint8_t insideValue=1, uint8_t outsideValue=0) -> Image"""
    return _SimpleITK.BinaryThreshold(image1, lowerThreshold, upperThreshold, insideValue, outsideValue)
class BinaryThresholdProjectionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BinaryThresholdProjectionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BinaryThresholdProjectionImageFilter

    def __init__(self):
        r"""__init__(BinaryThresholdProjectionImageFilter self) -> BinaryThresholdProjectionImageFilter"""
        _SimpleITK.BinaryThresholdProjectionImageFilter_swiginit(self, _SimpleITK.new_BinaryThresholdProjectionImageFilter())

    def SetProjectionDimension(self, ProjectionDimension):
        r"""SetProjectionDimension(BinaryThresholdProjectionImageFilter self, unsigned int ProjectionDimension)"""
        return _SimpleITK.BinaryThresholdProjectionImageFilter_SetProjectionDimension(self, ProjectionDimension)

    def GetProjectionDimension(self):
        r"""GetProjectionDimension(BinaryThresholdProjectionImageFilter self) -> unsigned int"""
        return _SimpleITK.BinaryThresholdProjectionImageFilter_GetProjectionDimension(self)

    def SetThresholdValue(self, ThresholdValue):
        r"""SetThresholdValue(BinaryThresholdProjectionImageFilter self, double ThresholdValue)"""
        return _SimpleITK.BinaryThresholdProjectionImageFilter_SetThresholdValue(self, ThresholdValue)

    def GetThresholdValue(self):
        r"""GetThresholdValue(BinaryThresholdProjectionImageFilter self) -> double"""
        return _SimpleITK.BinaryThresholdProjectionImageFilter_GetThresholdValue(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(BinaryThresholdProjectionImageFilter self, uint8_t ForegroundValue)"""
        return _SimpleITK.BinaryThresholdProjectionImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(BinaryThresholdProjectionImageFilter self) -> uint8_t"""
        return _SimpleITK.BinaryThresholdProjectionImageFilter_GetForegroundValue(self)

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(BinaryThresholdProjectionImageFilter self, uint8_t BackgroundValue)"""
        return _SimpleITK.BinaryThresholdProjectionImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(BinaryThresholdProjectionImageFilter self) -> uint8_t"""
        return _SimpleITK.BinaryThresholdProjectionImageFilter_GetBackgroundValue(self)

    def GetName(self):
        r"""GetName(BinaryThresholdProjectionImageFilter self) -> std::string"""
        return _SimpleITK.BinaryThresholdProjectionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BinaryThresholdProjectionImageFilter self) -> std::string"""
        return _SimpleITK.BinaryThresholdProjectionImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BinaryThresholdProjectionImageFilter self, Image image1) -> Image"""
        return _SimpleITK.BinaryThresholdProjectionImageFilter_Execute(self, image1)

# Register BinaryThresholdProjectionImageFilter in _SimpleITK:
_SimpleITK.BinaryThresholdProjectionImageFilter_swigregister(BinaryThresholdProjectionImageFilter)

def BinaryThresholdProjection(image1, projectionDimension=0, thresholdValue=0.0, foregroundValue=1, backgroundValue=0):
    r"""BinaryThresholdProjection(Image image1, unsigned int projectionDimension=0, double thresholdValue=0.0, uint8_t foregroundValue=1, uint8_t backgroundValue=0) -> Image"""
    return _SimpleITK.BinaryThresholdProjection(image1, projectionDimension, thresholdValue, foregroundValue, backgroundValue)
class BinomialBlurImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BinomialBlurImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BinomialBlurImageFilter

    def __init__(self):
        r"""__init__(BinomialBlurImageFilter self) -> BinomialBlurImageFilter"""
        _SimpleITK.BinomialBlurImageFilter_swiginit(self, _SimpleITK.new_BinomialBlurImageFilter())

    def SetRepetitions(self, Repetitions):
        r"""SetRepetitions(BinomialBlurImageFilter self, unsigned int Repetitions)"""
        return _SimpleITK.BinomialBlurImageFilter_SetRepetitions(self, Repetitions)

    def GetRepetitions(self):
        r"""GetRepetitions(BinomialBlurImageFilter self) -> unsigned int"""
        return _SimpleITK.BinomialBlurImageFilter_GetRepetitions(self)

    def GetName(self):
        r"""GetName(BinomialBlurImageFilter self) -> std::string"""
        return _SimpleITK.BinomialBlurImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BinomialBlurImageFilter self) -> std::string"""
        return _SimpleITK.BinomialBlurImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BinomialBlurImageFilter self, Image image1) -> Image"""
        return _SimpleITK.BinomialBlurImageFilter_Execute(self, image1)

# Register BinomialBlurImageFilter in _SimpleITK:
_SimpleITK.BinomialBlurImageFilter_swigregister(BinomialBlurImageFilter)

def BinomialBlur(image1, repetitions=1):
    r"""BinomialBlur(Image image1, unsigned int repetitions=1) -> Image"""
    return _SimpleITK.BinomialBlur(image1, repetitions)
class BitwiseNotImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BitwiseNotImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BitwiseNotImageFilter

    def __init__(self):
        r"""__init__(BitwiseNotImageFilter self) -> BitwiseNotImageFilter"""
        _SimpleITK.BitwiseNotImageFilter_swiginit(self, _SimpleITK.new_BitwiseNotImageFilter())

    def GetName(self):
        r"""GetName(BitwiseNotImageFilter self) -> std::string"""
        return _SimpleITK.BitwiseNotImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BitwiseNotImageFilter self) -> std::string"""
        return _SimpleITK.BitwiseNotImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BitwiseNotImageFilter self, Image image1) -> Image"""
        return _SimpleITK.BitwiseNotImageFilter_Execute(self, image1)

# Register BitwiseNotImageFilter in _SimpleITK:
_SimpleITK.BitwiseNotImageFilter_swigregister(BitwiseNotImageFilter)

def BitwiseNot(image1):
    r"""BitwiseNot(Image image1) -> Image"""
    return _SimpleITK.BitwiseNot(image1)
class BlackTopHatImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BlackTopHatImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BlackTopHatImageFilter

    def __init__(self):
        r"""__init__(BlackTopHatImageFilter self) -> BlackTopHatImageFilter"""
        _SimpleITK.BlackTopHatImageFilter_swiginit(self, _SimpleITK.new_BlackTopHatImageFilter())

    def SetKernelRadius(self, *args):
        r"""
        SetKernelRadius(BlackTopHatImageFilter self, VectorUInt32 KernelRadius)
        SetKernelRadius(BlackTopHatImageFilter self, unsigned int value)
        """
        return _SimpleITK.BlackTopHatImageFilter_SetKernelRadius(self, *args)

    def GetKernelRadius(self):
        r"""GetKernelRadius(BlackTopHatImageFilter self) -> VectorUInt32"""
        return _SimpleITK.BlackTopHatImageFilter_GetKernelRadius(self)

    def SetKernelType(self, KernelType):
        r"""SetKernelType(BlackTopHatImageFilter self, slicer_itk::simple::KernelEnum KernelType)"""
        return _SimpleITK.BlackTopHatImageFilter_SetKernelType(self, KernelType)

    def GetKernelType(self):
        r"""GetKernelType(BlackTopHatImageFilter self) -> slicer_itk::simple::KernelEnum"""
        return _SimpleITK.BlackTopHatImageFilter_GetKernelType(self)

    def SetSafeBorder(self, SafeBorder):
        r"""SetSafeBorder(BlackTopHatImageFilter self, bool SafeBorder)"""
        return _SimpleITK.BlackTopHatImageFilter_SetSafeBorder(self, SafeBorder)

    def SafeBorderOn(self):
        r"""SafeBorderOn(BlackTopHatImageFilter self)"""
        return _SimpleITK.BlackTopHatImageFilter_SafeBorderOn(self)

    def SafeBorderOff(self):
        r"""SafeBorderOff(BlackTopHatImageFilter self)"""
        return _SimpleITK.BlackTopHatImageFilter_SafeBorderOff(self)

    def GetSafeBorder(self):
        r"""GetSafeBorder(BlackTopHatImageFilter self) -> bool"""
        return _SimpleITK.BlackTopHatImageFilter_GetSafeBorder(self)

    def GetName(self):
        r"""GetName(BlackTopHatImageFilter self) -> std::string"""
        return _SimpleITK.BlackTopHatImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BlackTopHatImageFilter self) -> std::string"""
        return _SimpleITK.BlackTopHatImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BlackTopHatImageFilter self, Image image1) -> Image"""
        return _SimpleITK.BlackTopHatImageFilter_Execute(self, image1)

# Register BlackTopHatImageFilter in _SimpleITK:
_SimpleITK.BlackTopHatImageFilter_swigregister(BlackTopHatImageFilter)

def BlackTopHat(*args, **kwargs):
    r"""BlackTopHat(Image image1, VectorUInt32 kernelRadius=std::vector< uint32_t >(3, 1), slicer_itk::simple::KernelEnum kernelType=sitkBall, bool safeBorder=True) -> Image"""
    return _SimpleITK.BlackTopHat(*args, **kwargs)
class BoundedReciprocalImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BoundedReciprocalImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BoundedReciprocalImageFilter

    def __init__(self):
        r"""__init__(BoundedReciprocalImageFilter self) -> BoundedReciprocalImageFilter"""
        _SimpleITK.BoundedReciprocalImageFilter_swiginit(self, _SimpleITK.new_BoundedReciprocalImageFilter())

    def GetName(self):
        r"""GetName(BoundedReciprocalImageFilter self) -> std::string"""
        return _SimpleITK.BoundedReciprocalImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BoundedReciprocalImageFilter self) -> std::string"""
        return _SimpleITK.BoundedReciprocalImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BoundedReciprocalImageFilter self, Image image1) -> Image"""
        return _SimpleITK.BoundedReciprocalImageFilter_Execute(self, image1)

# Register BoundedReciprocalImageFilter in _SimpleITK:
_SimpleITK.BoundedReciprocalImageFilter_swigregister(BoundedReciprocalImageFilter)

def BoundedReciprocal(image1):
    r"""BoundedReciprocal(Image image1) -> Image"""
    return _SimpleITK.BoundedReciprocal(image1)
class BoxMeanImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BoxMeanImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BoxMeanImageFilter

    def __init__(self):
        r"""__init__(BoxMeanImageFilter self) -> BoxMeanImageFilter"""
        _SimpleITK.BoxMeanImageFilter_swiginit(self, _SimpleITK.new_BoxMeanImageFilter())

    def SetRadius(self, *args):
        r"""
        SetRadius(BoxMeanImageFilter self, VectorUInt32 Radius)
        SetRadius(BoxMeanImageFilter self, unsigned int value)
        """
        return _SimpleITK.BoxMeanImageFilter_SetRadius(self, *args)

    def GetRadius(self):
        r"""GetRadius(BoxMeanImageFilter self) -> VectorUInt32"""
        return _SimpleITK.BoxMeanImageFilter_GetRadius(self)

    def GetName(self):
        r"""GetName(BoxMeanImageFilter self) -> std::string"""
        return _SimpleITK.BoxMeanImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BoxMeanImageFilter self) -> std::string"""
        return _SimpleITK.BoxMeanImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BoxMeanImageFilter self, Image image1) -> Image"""
        return _SimpleITK.BoxMeanImageFilter_Execute(self, image1)

# Register BoxMeanImageFilter in _SimpleITK:
_SimpleITK.BoxMeanImageFilter_swigregister(BoxMeanImageFilter)

def BoxMean(*args, **kwargs):
    r"""BoxMean(Image image1, VectorUInt32 radius=std::vector< unsigned int >(3, 1)) -> Image"""
    return _SimpleITK.BoxMean(*args, **kwargs)
class BoxSigmaImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::BoxSigmaImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_BoxSigmaImageFilter

    def __init__(self):
        r"""__init__(BoxSigmaImageFilter self) -> BoxSigmaImageFilter"""
        _SimpleITK.BoxSigmaImageFilter_swiginit(self, _SimpleITK.new_BoxSigmaImageFilter())

    def SetRadius(self, *args):
        r"""
        SetRadius(BoxSigmaImageFilter self, VectorUInt32 Radius)
        SetRadius(BoxSigmaImageFilter self, unsigned int value)
        """
        return _SimpleITK.BoxSigmaImageFilter_SetRadius(self, *args)

    def GetRadius(self):
        r"""GetRadius(BoxSigmaImageFilter self) -> VectorUInt32"""
        return _SimpleITK.BoxSigmaImageFilter_GetRadius(self)

    def GetName(self):
        r"""GetName(BoxSigmaImageFilter self) -> std::string"""
        return _SimpleITK.BoxSigmaImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(BoxSigmaImageFilter self) -> std::string"""
        return _SimpleITK.BoxSigmaImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(BoxSigmaImageFilter self, Image image1) -> Image"""
        return _SimpleITK.BoxSigmaImageFilter_Execute(self, image1)

# Register BoxSigmaImageFilter in _SimpleITK:
_SimpleITK.BoxSigmaImageFilter_swigregister(BoxSigmaImageFilter)

def BoxSigma(*args, **kwargs):
    r"""BoxSigma(Image image1, VectorUInt32 radius=std::vector< unsigned int >(3, 1)) -> Image"""
    return _SimpleITK.BoxSigma(*args, **kwargs)
class CannyEdgeDetectionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::CannyEdgeDetectionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_CannyEdgeDetectionImageFilter

    def __init__(self):
        r"""__init__(CannyEdgeDetectionImageFilter self) -> CannyEdgeDetectionImageFilter"""
        _SimpleITK.CannyEdgeDetectionImageFilter_swiginit(self, _SimpleITK.new_CannyEdgeDetectionImageFilter())

    def SetLowerThreshold(self, LowerThreshold):
        r"""SetLowerThreshold(CannyEdgeDetectionImageFilter self, double LowerThreshold)"""
        return _SimpleITK.CannyEdgeDetectionImageFilter_SetLowerThreshold(self, LowerThreshold)

    def GetLowerThreshold(self):
        r"""GetLowerThreshold(CannyEdgeDetectionImageFilter self) -> double"""
        return _SimpleITK.CannyEdgeDetectionImageFilter_GetLowerThreshold(self)

    def SetUpperThreshold(self, UpperThreshold):
        r"""SetUpperThreshold(CannyEdgeDetectionImageFilter self, double UpperThreshold)"""
        return _SimpleITK.CannyEdgeDetectionImageFilter_SetUpperThreshold(self, UpperThreshold)

    def GetUpperThreshold(self):
        r"""GetUpperThreshold(CannyEdgeDetectionImageFilter self) -> double"""
        return _SimpleITK.CannyEdgeDetectionImageFilter_GetUpperThreshold(self)

    def SetVariance(self, *args):
        r"""
        SetVariance(CannyEdgeDetectionImageFilter self, VectorDouble Variance)
        SetVariance(CannyEdgeDetectionImageFilter self, double value)
        """
        return _SimpleITK.CannyEdgeDetectionImageFilter_SetVariance(self, *args)

    def GetVariance(self):
        r"""GetVariance(CannyEdgeDetectionImageFilter self) -> VectorDouble"""
        return _SimpleITK.CannyEdgeDetectionImageFilter_GetVariance(self)

    def SetMaximumError(self, *args):
        r"""
        SetMaximumError(CannyEdgeDetectionImageFilter self, VectorDouble MaximumError)
        SetMaximumError(CannyEdgeDetectionImageFilter self, double value)
        """
        return _SimpleITK.CannyEdgeDetectionImageFilter_SetMaximumError(self, *args)

    def GetMaximumError(self):
        r"""GetMaximumError(CannyEdgeDetectionImageFilter self) -> VectorDouble"""
        return _SimpleITK.CannyEdgeDetectionImageFilter_GetMaximumError(self)

    def GetName(self):
        r"""GetName(CannyEdgeDetectionImageFilter self) -> std::string"""
        return _SimpleITK.CannyEdgeDetectionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(CannyEdgeDetectionImageFilter self) -> std::string"""
        return _SimpleITK.CannyEdgeDetectionImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(CannyEdgeDetectionImageFilter self, Image image1) -> Image"""
        return _SimpleITK.CannyEdgeDetectionImageFilter_Execute(self, image1)

# Register CannyEdgeDetectionImageFilter in _SimpleITK:
_SimpleITK.CannyEdgeDetectionImageFilter_swigregister(CannyEdgeDetectionImageFilter)

def CannyEdgeDetection(*args, **kwargs):
    r"""CannyEdgeDetection(Image image1, double lowerThreshold=0.0, double upperThreshold=0.0, VectorDouble variance=std::vector< double >(3, 0.0), VectorDouble maximumError=std::vector< double >(3, 0.01)) -> Image"""
    return _SimpleITK.CannyEdgeDetection(*args, **kwargs)
class CannySegmentationLevelSetImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::CannySegmentationLevelSetImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_CannySegmentationLevelSetImageFilter

    def __init__(self):
        r"""__init__(CannySegmentationLevelSetImageFilter self) -> CannySegmentationLevelSetImageFilter"""
        _SimpleITK.CannySegmentationLevelSetImageFilter_swiginit(self, _SimpleITK.new_CannySegmentationLevelSetImageFilter())

    def SetThreshold(self, Threshold):
        r"""SetThreshold(CannySegmentationLevelSetImageFilter self, double Threshold)"""
        return _SimpleITK.CannySegmentationLevelSetImageFilter_SetThreshold(self, Threshold)

    def GetThreshold(self):
        r"""GetThreshold(CannySegmentationLevelSetImageFilter self) -> double"""
        return _SimpleITK.CannySegmentationLevelSetImageFilter_GetThreshold(self)

    def SetVariance(self, Variance):
        r"""SetVariance(CannySegmentationLevelSetImageFilter self, double Variance)"""
        return _SimpleITK.CannySegmentationLevelSetImageFilter_SetVariance(self, Variance)

    def GetVariance(self):
        r"""GetVariance(CannySegmentationLevelSetImageFilter self) -> double"""
        return _SimpleITK.CannySegmentationLevelSetImageFilter_GetVariance(self)

    def SetMaximumRMSError(self, MaximumRMSError):
        r"""SetMaximumRMSError(CannySegmentationLevelSetImageFilter self, double MaximumRMSError)"""
        return _SimpleITK.CannySegmentationLevelSetImageFilter_SetMaximumRMSError(self, MaximumRMSError)

    def GetMaximumRMSError(self):
        r"""GetMaximumRMSError(CannySegmentationLevelSetImageFilter self) -> double"""
        return _SimpleITK.CannySegmentationLevelSetImageFilter_GetMaximumRMSError(self)

    def SetPropagationScaling(self, PropagationScaling):
        r"""SetPropagationScaling(CannySegmentationLevelSetImageFilter self, double PropagationScaling)"""
        return _SimpleITK.CannySegmentationLevelSetImageFilter_SetPropagationScaling(self, PropagationScaling)

    def GetPropagationScaling(self):
        r"""GetPropagationScaling(CannySegmentationLevelSetImageFilter self) -> double"""
        return _SimpleITK.CannySegmentationLevelSetImageFilter_GetPropagationScaling(self)

    def SetCurvatureScaling(self, CurvatureScaling):
        r"""SetCurvatureScaling(CannySegmentationLevelSetImageFilter self, double CurvatureScaling)"""
        return _SimpleITK.CannySegmentationLevelSetImageFilter_SetCurvatureScaling(self, CurvatureScaling)

    def GetCurvatureScaling(self):
        r"""GetCurvatureScaling(CannySegmentationLevelSetImageFilter self) -> double"""
        return _SimpleITK.CannySegmentationLevelSetImageFilter_GetCurvatureScaling(self)

    def SetAdvectionScaling(self, AdvectionScaling):
        r"""SetAdvectionScaling(CannySegmentationLevelSetImageFilter self, double AdvectionScaling)"""
        return _SimpleITK.CannySegmentationLevelSetImageFilter_SetAdvectionScaling(self, AdvectionScaling)

    def GetAdvectionScaling(self):
        r"""GetAdvectionScaling(CannySegmentationLevelSetImageFilter self) -> double"""
        return _SimpleITK.CannySegmentationLevelSetImageFilter_GetAdvectionScaling(self)

    def SetNumberOfIterations(self, NumberOfIterations):
        r"""SetNumberOfIterations(CannySegmentationLevelSetImageFilter self, uint32_t NumberOfIterations)"""
        return _SimpleITK.CannySegmentationLevelSetImageFilter_SetNumberOfIterations(self, NumberOfIterations)

    def GetNumberOfIterations(self):
        r"""GetNumberOfIterations(CannySegmentationLevelSetImageFilter self) -> uint32_t"""
        return _SimpleITK.CannySegmentationLevelSetImageFilter_GetNumberOfIterations(self)

    def SetReverseExpansionDirection(self, ReverseExpansionDirection):
        r"""SetReverseExpansionDirection(CannySegmentationLevelSetImageFilter self, bool ReverseExpansionDirection)"""
        return _SimpleITK.CannySegmentationLevelSetImageFilter_SetReverseExpansionDirection(self, ReverseExpansionDirection)

    def ReverseExpansionDirectionOn(self):
        r"""ReverseExpansionDirectionOn(CannySegmentationLevelSetImageFilter self)"""
        return _SimpleITK.CannySegmentationLevelSetImageFilter_ReverseExpansionDirectionOn(self)

    def ReverseExpansionDirectionOff(self):
        r"""ReverseExpansionDirectionOff(CannySegmentationLevelSetImageFilter self)"""
        return _SimpleITK.CannySegmentationLevelSetImageFilter_ReverseExpansionDirectionOff(self)

    def GetReverseExpansionDirection(self):
        r"""GetReverseExpansionDirection(CannySegmentationLevelSetImageFilter self) -> bool"""
        return _SimpleITK.CannySegmentationLevelSetImageFilter_GetReverseExpansionDirection(self)

    def SetIsoSurfaceValue(self, IsoSurfaceValue):
        r"""SetIsoSurfaceValue(CannySegmentationLevelSetImageFilter self, double IsoSurfaceValue)"""
        return _SimpleITK.CannySegmentationLevelSetImageFilter_SetIsoSurfaceValue(self, IsoSurfaceValue)

    def GetIsoSurfaceValue(self):
        r"""GetIsoSurfaceValue(CannySegmentationLevelSetImageFilter self) -> double"""
        return _SimpleITK.CannySegmentationLevelSetImageFilter_GetIsoSurfaceValue(self)

    def GetElapsedIterations(self):
        r"""GetElapsedIterations(CannySegmentationLevelSetImageFilter self) -> uint32_t"""
        return _SimpleITK.CannySegmentationLevelSetImageFilter_GetElapsedIterations(self)

    def GetRMSChange(self):
        r"""GetRMSChange(CannySegmentationLevelSetImageFilter self) -> double"""
        return _SimpleITK.CannySegmentationLevelSetImageFilter_GetRMSChange(self)

    def GetCannyImage(self):
        r"""GetCannyImage(CannySegmentationLevelSetImageFilter self) -> Image"""
        return _SimpleITK.CannySegmentationLevelSetImageFilter_GetCannyImage(self)

    def GetName(self):
        r"""GetName(CannySegmentationLevelSetImageFilter self) -> std::string"""
        return _SimpleITK.CannySegmentationLevelSetImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(CannySegmentationLevelSetImageFilter self) -> std::string"""
        return _SimpleITK.CannySegmentationLevelSetImageFilter___str__(self)

    def Execute(self, initialImage, featureImage):
        r"""Execute(CannySegmentationLevelSetImageFilter self, Image initialImage, Image featureImage) -> Image"""
        return _SimpleITK.CannySegmentationLevelSetImageFilter_Execute(self, initialImage, featureImage)

# Register CannySegmentationLevelSetImageFilter in _SimpleITK:
_SimpleITK.CannySegmentationLevelSetImageFilter_swigregister(CannySegmentationLevelSetImageFilter)

def CannySegmentationLevelSet(initialImage, featureImage, threshold=0.0, variance=0.0, maximumRMSError=0.02, propagationScaling=1.0, curvatureScaling=1.0, advectionScaling=1.0, numberOfIterations=1000, reverseExpansionDirection=False, isoSurfaceValue=0.0):
    r"""CannySegmentationLevelSet(Image initialImage, Image featureImage, double threshold=0.0, double variance=0.0, double maximumRMSError=0.02, double propagationScaling=1.0, double curvatureScaling=1.0, double advectionScaling=1.0, uint32_t numberOfIterations=1000, bool reverseExpansionDirection=False, double isoSurfaceValue=0.0) -> Image"""
    return _SimpleITK.CannySegmentationLevelSet(initialImage, featureImage, threshold, variance, maximumRMSError, propagationScaling, curvatureScaling, advectionScaling, numberOfIterations, reverseExpansionDirection, isoSurfaceValue)
class ChangeLabelImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ChangeLabelImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ChangeLabelImageFilter

    def __init__(self):
        r"""__init__(ChangeLabelImageFilter self) -> ChangeLabelImageFilter"""
        _SimpleITK.ChangeLabelImageFilter_swiginit(self, _SimpleITK.new_ChangeLabelImageFilter())

    def SetChangeMap(self, ChangeMap):
        r"""SetChangeMap(ChangeLabelImageFilter self, DoubleDoubleMap ChangeMap)"""
        return _SimpleITK.ChangeLabelImageFilter_SetChangeMap(self, ChangeMap)

    def GetChangeMap(self):
        r"""GetChangeMap(ChangeLabelImageFilter self) -> DoubleDoubleMap"""
        return _SimpleITK.ChangeLabelImageFilter_GetChangeMap(self)

    def GetName(self):
        r"""GetName(ChangeLabelImageFilter self) -> std::string"""
        return _SimpleITK.ChangeLabelImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ChangeLabelImageFilter self) -> std::string"""
        return _SimpleITK.ChangeLabelImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ChangeLabelImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ChangeLabelImageFilter_Execute(self, image1)

# Register ChangeLabelImageFilter in _SimpleITK:
_SimpleITK.ChangeLabelImageFilter_swigregister(ChangeLabelImageFilter)

def ChangeLabel(*args, **kwargs):
    r"""ChangeLabel(Image image1, DoubleDoubleMap changeMap=std::map< double,double >()) -> Image"""
    return _SimpleITK.ChangeLabel(*args, **kwargs)
class ChangeLabelLabelMapFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ChangeLabelLabelMapFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ChangeLabelLabelMapFilter

    def __init__(self):
        r"""__init__(ChangeLabelLabelMapFilter self) -> ChangeLabelLabelMapFilter"""
        _SimpleITK.ChangeLabelLabelMapFilter_swiginit(self, _SimpleITK.new_ChangeLabelLabelMapFilter())

    def SetChangeMap(self, ChangeMap):
        r"""SetChangeMap(ChangeLabelLabelMapFilter self, DoubleDoubleMap ChangeMap)"""
        return _SimpleITK.ChangeLabelLabelMapFilter_SetChangeMap(self, ChangeMap)

    def GetChangeMap(self):
        r"""GetChangeMap(ChangeLabelLabelMapFilter self) -> DoubleDoubleMap"""
        return _SimpleITK.ChangeLabelLabelMapFilter_GetChangeMap(self)

    def GetName(self):
        r"""GetName(ChangeLabelLabelMapFilter self) -> std::string"""
        return _SimpleITK.ChangeLabelLabelMapFilter_GetName(self)

    def __str__(self):
        r"""__str__(ChangeLabelLabelMapFilter self) -> std::string"""
        return _SimpleITK.ChangeLabelLabelMapFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ChangeLabelLabelMapFilter self, Image image1) -> Image"""
        return _SimpleITK.ChangeLabelLabelMapFilter_Execute(self, image1)

# Register ChangeLabelLabelMapFilter in _SimpleITK:
_SimpleITK.ChangeLabelLabelMapFilter_swigregister(ChangeLabelLabelMapFilter)

def ChangeLabelLabelMap(*args, **kwargs):
    r"""ChangeLabelLabelMap(Image image1, DoubleDoubleMap changeMap=std::map< double,double >()) -> Image"""
    return _SimpleITK.ChangeLabelLabelMap(*args, **kwargs)
class CheckerBoardImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::CheckerBoardImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_CheckerBoardImageFilter

    def __init__(self):
        r"""__init__(CheckerBoardImageFilter self) -> CheckerBoardImageFilter"""
        _SimpleITK.CheckerBoardImageFilter_swiginit(self, _SimpleITK.new_CheckerBoardImageFilter())

    def SetCheckerPattern(self, *args):
        r"""
        SetCheckerPattern(CheckerBoardImageFilter self, VectorUInt32 CheckerPattern)
        SetCheckerPattern(CheckerBoardImageFilter self, uint32_t value)
        """
        return _SimpleITK.CheckerBoardImageFilter_SetCheckerPattern(self, *args)

    def GetCheckerPattern(self):
        r"""GetCheckerPattern(CheckerBoardImageFilter self) -> VectorUInt32"""
        return _SimpleITK.CheckerBoardImageFilter_GetCheckerPattern(self)

    def GetName(self):
        r"""GetName(CheckerBoardImageFilter self) -> std::string"""
        return _SimpleITK.CheckerBoardImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(CheckerBoardImageFilter self) -> std::string"""
        return _SimpleITK.CheckerBoardImageFilter___str__(self)

    def Execute(self, image1, image2):
        r"""Execute(CheckerBoardImageFilter self, Image image1, Image image2) -> Image"""
        return _SimpleITK.CheckerBoardImageFilter_Execute(self, image1, image2)

# Register CheckerBoardImageFilter in _SimpleITK:
_SimpleITK.CheckerBoardImageFilter_swigregister(CheckerBoardImageFilter)

def CheckerBoard(*args, **kwargs):
    r"""CheckerBoard(Image image1, Image image2, VectorUInt32 checkerPattern=std::vector< uint32_t >(3, 4)) -> Image"""
    return _SimpleITK.CheckerBoard(*args, **kwargs)
class ClampImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ClampImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ClampImageFilter

    def __init__(self):
        r"""__init__(ClampImageFilter self) -> ClampImageFilter"""
        _SimpleITK.ClampImageFilter_swiginit(self, _SimpleITK.new_ClampImageFilter())

    def SetOutputPixelType(self, OutputPixelType):
        r"""SetOutputPixelType(ClampImageFilter self, slicer_itk::simple::PixelIDValueEnum OutputPixelType)"""
        return _SimpleITK.ClampImageFilter_SetOutputPixelType(self, OutputPixelType)

    def GetOutputPixelType(self):
        r"""GetOutputPixelType(ClampImageFilter self) -> slicer_itk::simple::PixelIDValueEnum"""
        return _SimpleITK.ClampImageFilter_GetOutputPixelType(self)

    def SetLowerBound(self, LowerBound):
        r"""SetLowerBound(ClampImageFilter self, double LowerBound)"""
        return _SimpleITK.ClampImageFilter_SetLowerBound(self, LowerBound)

    def GetLowerBound(self):
        r"""GetLowerBound(ClampImageFilter self) -> double"""
        return _SimpleITK.ClampImageFilter_GetLowerBound(self)

    def SetUpperBound(self, UpperBound):
        r"""SetUpperBound(ClampImageFilter self, double UpperBound)"""
        return _SimpleITK.ClampImageFilter_SetUpperBound(self, UpperBound)

    def GetUpperBound(self):
        r"""GetUpperBound(ClampImageFilter self) -> double"""
        return _SimpleITK.ClampImageFilter_GetUpperBound(self)

    def GetName(self):
        r"""GetName(ClampImageFilter self) -> std::string"""
        return _SimpleITK.ClampImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ClampImageFilter self) -> std::string"""
        return _SimpleITK.ClampImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ClampImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ClampImageFilter_Execute(self, image1)

# Register ClampImageFilter in _SimpleITK:
_SimpleITK.ClampImageFilter_swigregister(ClampImageFilter)

def Clamp(*args, **kwargs):
    r"""Clamp(Image image1, slicer_itk::simple::PixelIDValueEnum outputPixelType=sitkUnknown, double lowerBound=-std::numeric_limits< double >::max(), double upperBound=std::numeric_limits< double >::max()) -> Image"""
    return _SimpleITK.Clamp(*args, **kwargs)
class ClosingByReconstructionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ClosingByReconstructionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ClosingByReconstructionImageFilter

    def __init__(self):
        r"""__init__(ClosingByReconstructionImageFilter self) -> ClosingByReconstructionImageFilter"""
        _SimpleITK.ClosingByReconstructionImageFilter_swiginit(self, _SimpleITK.new_ClosingByReconstructionImageFilter())

    def SetKernelRadius(self, *args):
        r"""
        SetKernelRadius(ClosingByReconstructionImageFilter self, VectorUInt32 KernelRadius)
        SetKernelRadius(ClosingByReconstructionImageFilter self, unsigned int value)
        """
        return _SimpleITK.ClosingByReconstructionImageFilter_SetKernelRadius(self, *args)

    def GetKernelRadius(self):
        r"""GetKernelRadius(ClosingByReconstructionImageFilter self) -> VectorUInt32"""
        return _SimpleITK.ClosingByReconstructionImageFilter_GetKernelRadius(self)

    def SetKernelType(self, KernelType):
        r"""SetKernelType(ClosingByReconstructionImageFilter self, slicer_itk::simple::KernelEnum KernelType)"""
        return _SimpleITK.ClosingByReconstructionImageFilter_SetKernelType(self, KernelType)

    def GetKernelType(self):
        r"""GetKernelType(ClosingByReconstructionImageFilter self) -> slicer_itk::simple::KernelEnum"""
        return _SimpleITK.ClosingByReconstructionImageFilter_GetKernelType(self)

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(ClosingByReconstructionImageFilter self, bool FullyConnected)"""
        return _SimpleITK.ClosingByReconstructionImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(ClosingByReconstructionImageFilter self)"""
        return _SimpleITK.ClosingByReconstructionImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(ClosingByReconstructionImageFilter self)"""
        return _SimpleITK.ClosingByReconstructionImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(ClosingByReconstructionImageFilter self) -> bool"""
        return _SimpleITK.ClosingByReconstructionImageFilter_GetFullyConnected(self)

    def SetPreserveIntensities(self, PreserveIntensities):
        r"""SetPreserveIntensities(ClosingByReconstructionImageFilter self, bool PreserveIntensities)"""
        return _SimpleITK.ClosingByReconstructionImageFilter_SetPreserveIntensities(self, PreserveIntensities)

    def PreserveIntensitiesOn(self):
        r"""PreserveIntensitiesOn(ClosingByReconstructionImageFilter self)"""
        return _SimpleITK.ClosingByReconstructionImageFilter_PreserveIntensitiesOn(self)

    def PreserveIntensitiesOff(self):
        r"""PreserveIntensitiesOff(ClosingByReconstructionImageFilter self)"""
        return _SimpleITK.ClosingByReconstructionImageFilter_PreserveIntensitiesOff(self)

    def GetPreserveIntensities(self):
        r"""GetPreserveIntensities(ClosingByReconstructionImageFilter self) -> bool"""
        return _SimpleITK.ClosingByReconstructionImageFilter_GetPreserveIntensities(self)

    def GetName(self):
        r"""GetName(ClosingByReconstructionImageFilter self) -> std::string"""
        return _SimpleITK.ClosingByReconstructionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ClosingByReconstructionImageFilter self) -> std::string"""
        return _SimpleITK.ClosingByReconstructionImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ClosingByReconstructionImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ClosingByReconstructionImageFilter_Execute(self, image1)

# Register ClosingByReconstructionImageFilter in _SimpleITK:
_SimpleITK.ClosingByReconstructionImageFilter_swigregister(ClosingByReconstructionImageFilter)

def ClosingByReconstruction(*args, **kwargs):
    r"""ClosingByReconstruction(Image image1, VectorUInt32 kernelRadius=std::vector< uint32_t >(3, 1), slicer_itk::simple::KernelEnum kernelType=sitkBall, bool fullyConnected=False, bool preserveIntensities=False) -> Image"""
    return _SimpleITK.ClosingByReconstruction(*args, **kwargs)
class CollidingFrontsImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::CollidingFrontsImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_CollidingFrontsImageFilter

    def __init__(self):
        r"""__init__(CollidingFrontsImageFilter self) -> CollidingFrontsImageFilter"""
        _SimpleITK.CollidingFrontsImageFilter_swiginit(self, _SimpleITK.new_CollidingFrontsImageFilter())

    def SetSeedPoints1(self, SeedPoints1):
        r"""SetSeedPoints1(CollidingFrontsImageFilter self, VectorUIntList SeedPoints1)"""
        return _SimpleITK.CollidingFrontsImageFilter_SetSeedPoints1(self, SeedPoints1)

    def GetSeedPoints1(self):
        r"""GetSeedPoints1(CollidingFrontsImageFilter self) -> VectorUIntList"""
        return _SimpleITK.CollidingFrontsImageFilter_GetSeedPoints1(self)

    def AddSeedPoint1(self, point):
        r"""AddSeedPoint1(CollidingFrontsImageFilter self, VectorUInt32 point)"""
        return _SimpleITK.CollidingFrontsImageFilter_AddSeedPoint1(self, point)

    def ClearSeedPoints1(self):
        r"""ClearSeedPoints1(CollidingFrontsImageFilter self)"""
        return _SimpleITK.CollidingFrontsImageFilter_ClearSeedPoints1(self)

    def SetSeedPoints2(self, SeedPoints2):
        r"""SetSeedPoints2(CollidingFrontsImageFilter self, VectorUIntList SeedPoints2)"""
        return _SimpleITK.CollidingFrontsImageFilter_SetSeedPoints2(self, SeedPoints2)

    def GetSeedPoints2(self):
        r"""GetSeedPoints2(CollidingFrontsImageFilter self) -> VectorUIntList"""
        return _SimpleITK.CollidingFrontsImageFilter_GetSeedPoints2(self)

    def AddSeedPoint2(self, point):
        r"""AddSeedPoint2(CollidingFrontsImageFilter self, VectorUInt32 point)"""
        return _SimpleITK.CollidingFrontsImageFilter_AddSeedPoint2(self, point)

    def ClearSeedPoints2(self):
        r"""ClearSeedPoints2(CollidingFrontsImageFilter self)"""
        return _SimpleITK.CollidingFrontsImageFilter_ClearSeedPoints2(self)

    def SetApplyConnectivity(self, ApplyConnectivity):
        r"""SetApplyConnectivity(CollidingFrontsImageFilter self, bool ApplyConnectivity)"""
        return _SimpleITK.CollidingFrontsImageFilter_SetApplyConnectivity(self, ApplyConnectivity)

    def ApplyConnectivityOn(self):
        r"""ApplyConnectivityOn(CollidingFrontsImageFilter self)"""
        return _SimpleITK.CollidingFrontsImageFilter_ApplyConnectivityOn(self)

    def ApplyConnectivityOff(self):
        r"""ApplyConnectivityOff(CollidingFrontsImageFilter self)"""
        return _SimpleITK.CollidingFrontsImageFilter_ApplyConnectivityOff(self)

    def GetApplyConnectivity(self):
        r"""GetApplyConnectivity(CollidingFrontsImageFilter self) -> bool"""
        return _SimpleITK.CollidingFrontsImageFilter_GetApplyConnectivity(self)

    def SetNegativeEpsilon(self, NegativeEpsilon):
        r"""SetNegativeEpsilon(CollidingFrontsImageFilter self, double NegativeEpsilon)"""
        return _SimpleITK.CollidingFrontsImageFilter_SetNegativeEpsilon(self, NegativeEpsilon)

    def GetNegativeEpsilon(self):
        r"""GetNegativeEpsilon(CollidingFrontsImageFilter self) -> double"""
        return _SimpleITK.CollidingFrontsImageFilter_GetNegativeEpsilon(self)

    def SetStopOnTargets(self, StopOnTargets):
        r"""SetStopOnTargets(CollidingFrontsImageFilter self, bool StopOnTargets)"""
        return _SimpleITK.CollidingFrontsImageFilter_SetStopOnTargets(self, StopOnTargets)

    def StopOnTargetsOn(self):
        r"""StopOnTargetsOn(CollidingFrontsImageFilter self)"""
        return _SimpleITK.CollidingFrontsImageFilter_StopOnTargetsOn(self)

    def StopOnTargetsOff(self):
        r"""StopOnTargetsOff(CollidingFrontsImageFilter self)"""
        return _SimpleITK.CollidingFrontsImageFilter_StopOnTargetsOff(self)

    def GetStopOnTargets(self):
        r"""GetStopOnTargets(CollidingFrontsImageFilter self) -> bool"""
        return _SimpleITK.CollidingFrontsImageFilter_GetStopOnTargets(self)

    def GetName(self):
        r"""GetName(CollidingFrontsImageFilter self) -> std::string"""
        return _SimpleITK.CollidingFrontsImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(CollidingFrontsImageFilter self) -> std::string"""
        return _SimpleITK.CollidingFrontsImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(CollidingFrontsImageFilter self, Image image1) -> Image"""
        return _SimpleITK.CollidingFrontsImageFilter_Execute(self, image1)

# Register CollidingFrontsImageFilter in _SimpleITK:
_SimpleITK.CollidingFrontsImageFilter_swigregister(CollidingFrontsImageFilter)

def CollidingFronts(*args, **kwargs):
    r"""CollidingFronts(Image image1, VectorUIntList seedPoints1=std::vector< std::vector< unsigned int > >(), VectorUIntList seedPoints2=std::vector< std::vector< unsigned int > >(), bool applyConnectivity=True, double negativeEpsilon=-1e-6, bool stopOnTargets=False) -> Image"""
    return _SimpleITK.CollidingFronts(*args, **kwargs)
class ComplexToImaginaryImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ComplexToImaginaryImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ComplexToImaginaryImageFilter

    def __init__(self):
        r"""__init__(ComplexToImaginaryImageFilter self) -> ComplexToImaginaryImageFilter"""
        _SimpleITK.ComplexToImaginaryImageFilter_swiginit(self, _SimpleITK.new_ComplexToImaginaryImageFilter())

    def GetName(self):
        r"""GetName(ComplexToImaginaryImageFilter self) -> std::string"""
        return _SimpleITK.ComplexToImaginaryImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ComplexToImaginaryImageFilter self) -> std::string"""
        return _SimpleITK.ComplexToImaginaryImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ComplexToImaginaryImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ComplexToImaginaryImageFilter_Execute(self, image1)

# Register ComplexToImaginaryImageFilter in _SimpleITK:
_SimpleITK.ComplexToImaginaryImageFilter_swigregister(ComplexToImaginaryImageFilter)

def ComplexToImaginary(image1):
    r"""ComplexToImaginary(Image image1) -> Image"""
    return _SimpleITK.ComplexToImaginary(image1)
class ComplexToModulusImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ComplexToModulusImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ComplexToModulusImageFilter

    def __init__(self):
        r"""__init__(ComplexToModulusImageFilter self) -> ComplexToModulusImageFilter"""
        _SimpleITK.ComplexToModulusImageFilter_swiginit(self, _SimpleITK.new_ComplexToModulusImageFilter())

    def GetName(self):
        r"""GetName(ComplexToModulusImageFilter self) -> std::string"""
        return _SimpleITK.ComplexToModulusImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ComplexToModulusImageFilter self) -> std::string"""
        return _SimpleITK.ComplexToModulusImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ComplexToModulusImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ComplexToModulusImageFilter_Execute(self, image1)

# Register ComplexToModulusImageFilter in _SimpleITK:
_SimpleITK.ComplexToModulusImageFilter_swigregister(ComplexToModulusImageFilter)

def ComplexToModulus(image1):
    r"""ComplexToModulus(Image image1) -> Image"""
    return _SimpleITK.ComplexToModulus(image1)
class ComplexToPhaseImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ComplexToPhaseImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ComplexToPhaseImageFilter

    def __init__(self):
        r"""__init__(ComplexToPhaseImageFilter self) -> ComplexToPhaseImageFilter"""
        _SimpleITK.ComplexToPhaseImageFilter_swiginit(self, _SimpleITK.new_ComplexToPhaseImageFilter())

    def GetName(self):
        r"""GetName(ComplexToPhaseImageFilter self) -> std::string"""
        return _SimpleITK.ComplexToPhaseImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ComplexToPhaseImageFilter self) -> std::string"""
        return _SimpleITK.ComplexToPhaseImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ComplexToPhaseImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ComplexToPhaseImageFilter_Execute(self, image1)

# Register ComplexToPhaseImageFilter in _SimpleITK:
_SimpleITK.ComplexToPhaseImageFilter_swigregister(ComplexToPhaseImageFilter)

def ComplexToPhase(image1):
    r"""ComplexToPhase(Image image1) -> Image"""
    return _SimpleITK.ComplexToPhase(image1)
class ComplexToRealImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ComplexToRealImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ComplexToRealImageFilter

    def __init__(self):
        r"""__init__(ComplexToRealImageFilter self) -> ComplexToRealImageFilter"""
        _SimpleITK.ComplexToRealImageFilter_swiginit(self, _SimpleITK.new_ComplexToRealImageFilter())

    def GetName(self):
        r"""GetName(ComplexToRealImageFilter self) -> std::string"""
        return _SimpleITK.ComplexToRealImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ComplexToRealImageFilter self) -> std::string"""
        return _SimpleITK.ComplexToRealImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ComplexToRealImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ComplexToRealImageFilter_Execute(self, image1)

# Register ComplexToRealImageFilter in _SimpleITK:
_SimpleITK.ComplexToRealImageFilter_swigregister(ComplexToRealImageFilter)

def ComplexToReal(image1):
    r"""ComplexToReal(Image image1) -> Image"""
    return _SimpleITK.ComplexToReal(image1)
class ComposeImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ComposeImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ComposeImageFilter

    def __init__(self):
        r"""__init__(ComposeImageFilter self) -> ComposeImageFilter"""
        _SimpleITK.ComposeImageFilter_swiginit(self, _SimpleITK.new_ComposeImageFilter())

    def GetName(self):
        r"""GetName(ComposeImageFilter self) -> std::string"""
        return _SimpleITK.ComposeImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ComposeImageFilter self) -> std::string"""
        return _SimpleITK.ComposeImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(ComposeImageFilter self, VectorOfImage images) -> Image
        Execute(ComposeImageFilter self, Image image1) -> Image
        Execute(ComposeImageFilter self, Image image1, Image image2) -> Image
        Execute(ComposeImageFilter self, Image image1, Image image2, Image image3) -> Image
        Execute(ComposeImageFilter self, Image image1, Image image2, Image image3, Image image4) -> Image
        Execute(ComposeImageFilter self, Image image1, Image image2, Image image3, Image image4, Image image5) -> Image
        """
        return _SimpleITK.ComposeImageFilter_Execute(self, *args)

# Register ComposeImageFilter in _SimpleITK:
_SimpleITK.ComposeImageFilter_swigregister(ComposeImageFilter)

def Compose(*args):
    r"""
    Compose(VectorOfImage images) -> Image
    Compose(Image image1) -> Image
    Compose(Image image1, Image image2) -> Image
    Compose(Image image1, Image image2, Image image3) -> Image
    Compose(Image image1, Image image2, Image image3, Image image4) -> Image
    Compose(Image image1, Image image2, Image image3, Image image4, Image image5) -> Image
    """
    return _SimpleITK.Compose(*args)
class ConfidenceConnectedImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ConfidenceConnectedImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ConfidenceConnectedImageFilter

    def __init__(self):
        r"""__init__(ConfidenceConnectedImageFilter self) -> ConfidenceConnectedImageFilter"""
        _SimpleITK.ConfidenceConnectedImageFilter_swiginit(self, _SimpleITK.new_ConfidenceConnectedImageFilter())

    def SetSeedList(self, SeedList):
        r"""SetSeedList(ConfidenceConnectedImageFilter self, VectorUIntList SeedList)"""
        return _SimpleITK.ConfidenceConnectedImageFilter_SetSeedList(self, SeedList)

    def GetSeedList(self):
        r"""GetSeedList(ConfidenceConnectedImageFilter self) -> VectorUIntList"""
        return _SimpleITK.ConfidenceConnectedImageFilter_GetSeedList(self)

    def AddSeed(self, point):
        r"""AddSeed(ConfidenceConnectedImageFilter self, VectorUInt32 point)"""
        return _SimpleITK.ConfidenceConnectedImageFilter_AddSeed(self, point)

    def ClearSeeds(self):
        r"""ClearSeeds(ConfidenceConnectedImageFilter self)"""
        return _SimpleITK.ConfidenceConnectedImageFilter_ClearSeeds(self)

    def SetNumberOfIterations(self, NumberOfIterations):
        r"""SetNumberOfIterations(ConfidenceConnectedImageFilter self, unsigned int NumberOfIterations)"""
        return _SimpleITK.ConfidenceConnectedImageFilter_SetNumberOfIterations(self, NumberOfIterations)

    def GetNumberOfIterations(self):
        r"""GetNumberOfIterations(ConfidenceConnectedImageFilter self) -> unsigned int"""
        return _SimpleITK.ConfidenceConnectedImageFilter_GetNumberOfIterations(self)

    def SetMultiplier(self, Multiplier):
        r"""SetMultiplier(ConfidenceConnectedImageFilter self, double Multiplier)"""
        return _SimpleITK.ConfidenceConnectedImageFilter_SetMultiplier(self, Multiplier)

    def GetMultiplier(self):
        r"""GetMultiplier(ConfidenceConnectedImageFilter self) -> double"""
        return _SimpleITK.ConfidenceConnectedImageFilter_GetMultiplier(self)

    def SetInitialNeighborhoodRadius(self, InitialNeighborhoodRadius):
        r"""SetInitialNeighborhoodRadius(ConfidenceConnectedImageFilter self, unsigned int InitialNeighborhoodRadius)"""
        return _SimpleITK.ConfidenceConnectedImageFilter_SetInitialNeighborhoodRadius(self, InitialNeighborhoodRadius)

    def GetInitialNeighborhoodRadius(self):
        r"""GetInitialNeighborhoodRadius(ConfidenceConnectedImageFilter self) -> unsigned int"""
        return _SimpleITK.ConfidenceConnectedImageFilter_GetInitialNeighborhoodRadius(self)

    def SetReplaceValue(self, ReplaceValue):
        r"""SetReplaceValue(ConfidenceConnectedImageFilter self, uint8_t ReplaceValue)"""
        return _SimpleITK.ConfidenceConnectedImageFilter_SetReplaceValue(self, ReplaceValue)

    def GetReplaceValue(self):
        r"""GetReplaceValue(ConfidenceConnectedImageFilter self) -> uint8_t"""
        return _SimpleITK.ConfidenceConnectedImageFilter_GetReplaceValue(self)

    def GetMean(self):
        r"""GetMean(ConfidenceConnectedImageFilter self) -> double"""
        return _SimpleITK.ConfidenceConnectedImageFilter_GetMean(self)

    def GetVariance(self):
        r"""GetVariance(ConfidenceConnectedImageFilter self) -> double"""
        return _SimpleITK.ConfidenceConnectedImageFilter_GetVariance(self)

    def GetName(self):
        r"""GetName(ConfidenceConnectedImageFilter self) -> std::string"""
        return _SimpleITK.ConfidenceConnectedImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ConfidenceConnectedImageFilter self) -> std::string"""
        return _SimpleITK.ConfidenceConnectedImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ConfidenceConnectedImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ConfidenceConnectedImageFilter_Execute(self, image1)

# Register ConfidenceConnectedImageFilter in _SimpleITK:
_SimpleITK.ConfidenceConnectedImageFilter_swigregister(ConfidenceConnectedImageFilter)

def ConfidenceConnected(*args, **kwargs):
    r"""ConfidenceConnected(Image image1, VectorUIntList seedList=std::vector< std::vector< unsigned int > >(), unsigned int numberOfIterations=4, double multiplier=4.5, unsigned int initialNeighborhoodRadius=1, uint8_t replaceValue=1) -> Image"""
    return _SimpleITK.ConfidenceConnected(*args, **kwargs)
class ConnectedComponentImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ConnectedComponentImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ConnectedComponentImageFilter

    def __init__(self):
        r"""__init__(ConnectedComponentImageFilter self) -> ConnectedComponentImageFilter"""
        _SimpleITK.ConnectedComponentImageFilter_swiginit(self, _SimpleITK.new_ConnectedComponentImageFilter())

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(ConnectedComponentImageFilter self, bool FullyConnected)"""
        return _SimpleITK.ConnectedComponentImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(ConnectedComponentImageFilter self)"""
        return _SimpleITK.ConnectedComponentImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(ConnectedComponentImageFilter self)"""
        return _SimpleITK.ConnectedComponentImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(ConnectedComponentImageFilter self) -> bool"""
        return _SimpleITK.ConnectedComponentImageFilter_GetFullyConnected(self)

    def GetObjectCount(self):
        r"""GetObjectCount(ConnectedComponentImageFilter self) -> uint32_t"""
        return _SimpleITK.ConnectedComponentImageFilter_GetObjectCount(self)

    def GetName(self):
        r"""GetName(ConnectedComponentImageFilter self) -> std::string"""
        return _SimpleITK.ConnectedComponentImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ConnectedComponentImageFilter self) -> std::string"""
        return _SimpleITK.ConnectedComponentImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(ConnectedComponentImageFilter self, Image image, Image maskImage) -> Image
        Execute(ConnectedComponentImageFilter self, Image image) -> Image
        """
        return _SimpleITK.ConnectedComponentImageFilter_Execute(self, *args)

# Register ConnectedComponentImageFilter in _SimpleITK:
_SimpleITK.ConnectedComponentImageFilter_swigregister(ConnectedComponentImageFilter)

def ConnectedComponent(*args):
    r"""
    ConnectedComponent(Image image, Image maskImage, bool fullyConnected=False) -> Image
    ConnectedComponent(Image image, bool fullyConnected=False) -> Image
    """
    return _SimpleITK.ConnectedComponent(*args)
class ConnectedThresholdImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ConnectedThresholdImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ConnectedThresholdImageFilter

    def __init__(self):
        r"""__init__(ConnectedThresholdImageFilter self) -> ConnectedThresholdImageFilter"""
        _SimpleITK.ConnectedThresholdImageFilter_swiginit(self, _SimpleITK.new_ConnectedThresholdImageFilter())

    def SetSeedList(self, SeedList):
        r"""SetSeedList(ConnectedThresholdImageFilter self, VectorUIntList SeedList)"""
        return _SimpleITK.ConnectedThresholdImageFilter_SetSeedList(self, SeedList)

    def GetSeedList(self):
        r"""GetSeedList(ConnectedThresholdImageFilter self) -> VectorUIntList"""
        return _SimpleITK.ConnectedThresholdImageFilter_GetSeedList(self)

    def AddSeed(self, point):
        r"""AddSeed(ConnectedThresholdImageFilter self, VectorUInt32 point)"""
        return _SimpleITK.ConnectedThresholdImageFilter_AddSeed(self, point)

    def ClearSeeds(self):
        r"""ClearSeeds(ConnectedThresholdImageFilter self)"""
        return _SimpleITK.ConnectedThresholdImageFilter_ClearSeeds(self)

    def SetLower(self, Lower):
        r"""SetLower(ConnectedThresholdImageFilter self, double Lower)"""
        return _SimpleITK.ConnectedThresholdImageFilter_SetLower(self, Lower)

    def GetLower(self):
        r"""GetLower(ConnectedThresholdImageFilter self) -> double"""
        return _SimpleITK.ConnectedThresholdImageFilter_GetLower(self)

    def SetUpper(self, Upper):
        r"""SetUpper(ConnectedThresholdImageFilter self, double Upper)"""
        return _SimpleITK.ConnectedThresholdImageFilter_SetUpper(self, Upper)

    def GetUpper(self):
        r"""GetUpper(ConnectedThresholdImageFilter self) -> double"""
        return _SimpleITK.ConnectedThresholdImageFilter_GetUpper(self)

    def SetReplaceValue(self, ReplaceValue):
        r"""SetReplaceValue(ConnectedThresholdImageFilter self, uint8_t ReplaceValue)"""
        return _SimpleITK.ConnectedThresholdImageFilter_SetReplaceValue(self, ReplaceValue)

    def GetReplaceValue(self):
        r"""GetReplaceValue(ConnectedThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.ConnectedThresholdImageFilter_GetReplaceValue(self)
    FaceConnectivity = _SimpleITK.ConnectedThresholdImageFilter_FaceConnectivity
    
    FullConnectivity = _SimpleITK.ConnectedThresholdImageFilter_FullConnectivity
    

    def SetConnectivity(self, Connectivity):
        r"""SetConnectivity(ConnectedThresholdImageFilter self, slicer_itk::simple::ConnectedThresholdImageFilter::ConnectivityType Connectivity)"""
        return _SimpleITK.ConnectedThresholdImageFilter_SetConnectivity(self, Connectivity)

    def GetConnectivity(self):
        r"""GetConnectivity(ConnectedThresholdImageFilter self) -> slicer_itk::simple::ConnectedThresholdImageFilter::ConnectivityType"""
        return _SimpleITK.ConnectedThresholdImageFilter_GetConnectivity(self)

    def GetName(self):
        r"""GetName(ConnectedThresholdImageFilter self) -> std::string"""
        return _SimpleITK.ConnectedThresholdImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ConnectedThresholdImageFilter self) -> std::string"""
        return _SimpleITK.ConnectedThresholdImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ConnectedThresholdImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ConnectedThresholdImageFilter_Execute(self, image1)

# Register ConnectedThresholdImageFilter in _SimpleITK:
_SimpleITK.ConnectedThresholdImageFilter_swigregister(ConnectedThresholdImageFilter)

def ConnectedThreshold(*args, **kwargs):
    r"""ConnectedThreshold(Image image1, VectorUIntList seedList=std::vector< std::vector< unsigned int > >(), double lower=0, double upper=1, uint8_t replaceValue=1, slicer_itk::simple::ConnectedThresholdImageFilter::ConnectivityType connectivity=FaceConnectivity) -> Image"""
    return _SimpleITK.ConnectedThreshold(*args, **kwargs)
class ConstantPadImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ConstantPadImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ConstantPadImageFilter

    def __init__(self):
        r"""__init__(ConstantPadImageFilter self) -> ConstantPadImageFilter"""
        _SimpleITK.ConstantPadImageFilter_swiginit(self, _SimpleITK.new_ConstantPadImageFilter())

    def SetPadLowerBound(self, PadLowerBound):
        r"""SetPadLowerBound(ConstantPadImageFilter self, VectorUInt32 PadLowerBound)"""
        return _SimpleITK.ConstantPadImageFilter_SetPadLowerBound(self, PadLowerBound)

    def GetPadLowerBound(self):
        r"""GetPadLowerBound(ConstantPadImageFilter self) -> VectorUInt32"""
        return _SimpleITK.ConstantPadImageFilter_GetPadLowerBound(self)

    def SetPadUpperBound(self, PadUpperBound):
        r"""SetPadUpperBound(ConstantPadImageFilter self, VectorUInt32 PadUpperBound)"""
        return _SimpleITK.ConstantPadImageFilter_SetPadUpperBound(self, PadUpperBound)

    def GetPadUpperBound(self):
        r"""GetPadUpperBound(ConstantPadImageFilter self) -> VectorUInt32"""
        return _SimpleITK.ConstantPadImageFilter_GetPadUpperBound(self)

    def SetConstant(self, Constant):
        r"""SetConstant(ConstantPadImageFilter self, double Constant)"""
        return _SimpleITK.ConstantPadImageFilter_SetConstant(self, Constant)

    def GetConstant(self):
        r"""GetConstant(ConstantPadImageFilter self) -> double"""
        return _SimpleITK.ConstantPadImageFilter_GetConstant(self)

    def GetName(self):
        r"""GetName(ConstantPadImageFilter self) -> std::string"""
        return _SimpleITK.ConstantPadImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ConstantPadImageFilter self) -> std::string"""
        return _SimpleITK.ConstantPadImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ConstantPadImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ConstantPadImageFilter_Execute(self, image1)

# Register ConstantPadImageFilter in _SimpleITK:
_SimpleITK.ConstantPadImageFilter_swigregister(ConstantPadImageFilter)

def ConstantPad(*args, **kwargs):
    r"""ConstantPad(Image image1, VectorUInt32 padLowerBound=std::vector< unsigned int >(3, 0), VectorUInt32 padUpperBound=std::vector< unsigned int >(3, 0), double constant=0.0) -> Image"""
    return _SimpleITK.ConstantPad(*args, **kwargs)
class ConvolutionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ConvolutionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ConvolutionImageFilter

    def __init__(self):
        r"""__init__(ConvolutionImageFilter self) -> ConvolutionImageFilter"""
        _SimpleITK.ConvolutionImageFilter_swiginit(self, _SimpleITK.new_ConvolutionImageFilter())

    def SetNormalize(self, Normalize):
        r"""SetNormalize(ConvolutionImageFilter self, bool Normalize)"""
        return _SimpleITK.ConvolutionImageFilter_SetNormalize(self, Normalize)

    def NormalizeOn(self):
        r"""NormalizeOn(ConvolutionImageFilter self)"""
        return _SimpleITK.ConvolutionImageFilter_NormalizeOn(self)

    def NormalizeOff(self):
        r"""NormalizeOff(ConvolutionImageFilter self)"""
        return _SimpleITK.ConvolutionImageFilter_NormalizeOff(self)

    def GetNormalize(self):
        r"""GetNormalize(ConvolutionImageFilter self) -> bool"""
        return _SimpleITK.ConvolutionImageFilter_GetNormalize(self)
    ZERO_PAD = _SimpleITK.ConvolutionImageFilter_ZERO_PAD
    
    ZERO_FLUX_NEUMANN_PAD = _SimpleITK.ConvolutionImageFilter_ZERO_FLUX_NEUMANN_PAD
    
    PERIODIC_PAD = _SimpleITK.ConvolutionImageFilter_PERIODIC_PAD
    

    def SetBoundaryCondition(self, BoundaryCondition):
        r"""SetBoundaryCondition(ConvolutionImageFilter self, slicer_itk::simple::ConvolutionImageFilter::BoundaryConditionType BoundaryCondition)"""
        return _SimpleITK.ConvolutionImageFilter_SetBoundaryCondition(self, BoundaryCondition)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(ConvolutionImageFilter self) -> slicer_itk::simple::ConvolutionImageFilter::BoundaryConditionType"""
        return _SimpleITK.ConvolutionImageFilter_GetBoundaryCondition(self)
    SAME = _SimpleITK.ConvolutionImageFilter_SAME
    
    VALID = _SimpleITK.ConvolutionImageFilter_VALID
    

    def SetOutputRegionMode(self, OutputRegionMode):
        r"""SetOutputRegionMode(ConvolutionImageFilter self, slicer_itk::simple::ConvolutionImageFilter::OutputRegionModeType OutputRegionMode)"""
        return _SimpleITK.ConvolutionImageFilter_SetOutputRegionMode(self, OutputRegionMode)

    def GetOutputRegionMode(self):
        r"""GetOutputRegionMode(ConvolutionImageFilter self) -> slicer_itk::simple::ConvolutionImageFilter::OutputRegionModeType"""
        return _SimpleITK.ConvolutionImageFilter_GetOutputRegionMode(self)

    def GetName(self):
        r"""GetName(ConvolutionImageFilter self) -> std::string"""
        return _SimpleITK.ConvolutionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ConvolutionImageFilter self) -> std::string"""
        return _SimpleITK.ConvolutionImageFilter___str__(self)

    def Execute(self, image, kernelImage):
        r"""Execute(ConvolutionImageFilter self, Image image, Image kernelImage) -> Image"""
        return _SimpleITK.ConvolutionImageFilter_Execute(self, image, kernelImage)

# Register ConvolutionImageFilter in _SimpleITK:
_SimpleITK.ConvolutionImageFilter_swigregister(ConvolutionImageFilter)

def Convolution(*args, **kwargs):
    r"""Convolution(Image image, Image kernelImage, bool normalize=False, slicer_itk::simple::ConvolutionImageFilter::BoundaryConditionType boundaryCondition=ZERO_FLUX_NEUMANN_PAD, slicer_itk::simple::ConvolutionImageFilter::OutputRegionModeType outputRegionMode=SAME) -> Image"""
    return _SimpleITK.Convolution(*args, **kwargs)
class CosImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::CosImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_CosImageFilter

    def __init__(self):
        r"""__init__(CosImageFilter self) -> CosImageFilter"""
        _SimpleITK.CosImageFilter_swiginit(self, _SimpleITK.new_CosImageFilter())

    def GetName(self):
        r"""GetName(CosImageFilter self) -> std::string"""
        return _SimpleITK.CosImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(CosImageFilter self) -> std::string"""
        return _SimpleITK.CosImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(CosImageFilter self, Image image1) -> Image"""
        return _SimpleITK.CosImageFilter_Execute(self, image1)

# Register CosImageFilter in _SimpleITK:
_SimpleITK.CosImageFilter_swigregister(CosImageFilter)

def Cos(image1):
    r"""Cos(Image image1) -> Image"""
    return _SimpleITK.Cos(image1)
class CropImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::CropImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_CropImageFilter

    def __init__(self):
        r"""__init__(CropImageFilter self) -> CropImageFilter"""
        _SimpleITK.CropImageFilter_swiginit(self, _SimpleITK.new_CropImageFilter())

    def SetLowerBoundaryCropSize(self, LowerBoundaryCropSize):
        r"""SetLowerBoundaryCropSize(CropImageFilter self, VectorUInt32 LowerBoundaryCropSize)"""
        return _SimpleITK.CropImageFilter_SetLowerBoundaryCropSize(self, LowerBoundaryCropSize)

    def GetLowerBoundaryCropSize(self):
        r"""GetLowerBoundaryCropSize(CropImageFilter self) -> VectorUInt32"""
        return _SimpleITK.CropImageFilter_GetLowerBoundaryCropSize(self)

    def SetUpperBoundaryCropSize(self, UpperBoundaryCropSize):
        r"""SetUpperBoundaryCropSize(CropImageFilter self, VectorUInt32 UpperBoundaryCropSize)"""
        return _SimpleITK.CropImageFilter_SetUpperBoundaryCropSize(self, UpperBoundaryCropSize)

    def GetUpperBoundaryCropSize(self):
        r"""GetUpperBoundaryCropSize(CropImageFilter self) -> VectorUInt32"""
        return _SimpleITK.CropImageFilter_GetUpperBoundaryCropSize(self)

    def GetName(self):
        r"""GetName(CropImageFilter self) -> std::string"""
        return _SimpleITK.CropImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(CropImageFilter self) -> std::string"""
        return _SimpleITK.CropImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(CropImageFilter self, Image image1) -> Image"""
        return _SimpleITK.CropImageFilter_Execute(self, image1)

# Register CropImageFilter in _SimpleITK:
_SimpleITK.CropImageFilter_swigregister(CropImageFilter)

def Crop(*args, **kwargs):
    r"""Crop(Image image1, VectorUInt32 lowerBoundaryCropSize=std::vector< unsigned int >(3, 0), VectorUInt32 upperBoundaryCropSize=std::vector< unsigned int >(3, 0)) -> Image"""
    return _SimpleITK.Crop(*args, **kwargs)
class CurvatureAnisotropicDiffusionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::CurvatureAnisotropicDiffusionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_CurvatureAnisotropicDiffusionImageFilter

    def __init__(self):
        r"""__init__(CurvatureAnisotropicDiffusionImageFilter self) -> CurvatureAnisotropicDiffusionImageFilter"""
        _SimpleITK.CurvatureAnisotropicDiffusionImageFilter_swiginit(self, _SimpleITK.new_CurvatureAnisotropicDiffusionImageFilter())

    def SetTimeStep(self, TimeStep):
        r"""SetTimeStep(CurvatureAnisotropicDiffusionImageFilter self, double TimeStep)"""
        return _SimpleITK.CurvatureAnisotropicDiffusionImageFilter_SetTimeStep(self, TimeStep)

    def GetTimeStep(self):
        r"""GetTimeStep(CurvatureAnisotropicDiffusionImageFilter self) -> double"""
        return _SimpleITK.CurvatureAnisotropicDiffusionImageFilter_GetTimeStep(self)

    def SetConductanceParameter(self, ConductanceParameter):
        r"""SetConductanceParameter(CurvatureAnisotropicDiffusionImageFilter self, double ConductanceParameter)"""
        return _SimpleITK.CurvatureAnisotropicDiffusionImageFilter_SetConductanceParameter(self, ConductanceParameter)

    def GetConductanceParameter(self):
        r"""GetConductanceParameter(CurvatureAnisotropicDiffusionImageFilter self) -> double"""
        return _SimpleITK.CurvatureAnisotropicDiffusionImageFilter_GetConductanceParameter(self)

    def SetConductanceScalingUpdateInterval(self, ConductanceScalingUpdateInterval):
        r"""SetConductanceScalingUpdateInterval(CurvatureAnisotropicDiffusionImageFilter self, unsigned int ConductanceScalingUpdateInterval)"""
        return _SimpleITK.CurvatureAnisotropicDiffusionImageFilter_SetConductanceScalingUpdateInterval(self, ConductanceScalingUpdateInterval)

    def GetConductanceScalingUpdateInterval(self):
        r"""GetConductanceScalingUpdateInterval(CurvatureAnisotropicDiffusionImageFilter self) -> unsigned int"""
        return _SimpleITK.CurvatureAnisotropicDiffusionImageFilter_GetConductanceScalingUpdateInterval(self)

    def SetNumberOfIterations(self, NumberOfIterations):
        r"""SetNumberOfIterations(CurvatureAnisotropicDiffusionImageFilter self, uint32_t NumberOfIterations)"""
        return _SimpleITK.CurvatureAnisotropicDiffusionImageFilter_SetNumberOfIterations(self, NumberOfIterations)

    def GetNumberOfIterations(self):
        r"""GetNumberOfIterations(CurvatureAnisotropicDiffusionImageFilter self) -> uint32_t"""
        return _SimpleITK.CurvatureAnisotropicDiffusionImageFilter_GetNumberOfIterations(self)

    def GetName(self):
        r"""GetName(CurvatureAnisotropicDiffusionImageFilter self) -> std::string"""
        return _SimpleITK.CurvatureAnisotropicDiffusionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(CurvatureAnisotropicDiffusionImageFilter self) -> std::string"""
        return _SimpleITK.CurvatureAnisotropicDiffusionImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(CurvatureAnisotropicDiffusionImageFilter self, Image image1) -> Image"""
        return _SimpleITK.CurvatureAnisotropicDiffusionImageFilter_Execute(self, image1)

    def EstimateOptimalTimeStep(self, inImage):
        r"""EstimateOptimalTimeStep(CurvatureAnisotropicDiffusionImageFilter self, Image inImage) -> double"""
        return _SimpleITK.CurvatureAnisotropicDiffusionImageFilter_EstimateOptimalTimeStep(self, inImage)

# Register CurvatureAnisotropicDiffusionImageFilter in _SimpleITK:
_SimpleITK.CurvatureAnisotropicDiffusionImageFilter_swigregister(CurvatureAnisotropicDiffusionImageFilter)

def CurvatureAnisotropicDiffusion(image1, timeStep=0.0625, conductanceParameter=3.0, conductanceScalingUpdateInterval=1, numberOfIterations=5):
    r"""CurvatureAnisotropicDiffusion(Image image1, double timeStep=0.0625, double conductanceParameter=3.0, unsigned int conductanceScalingUpdateInterval=1, uint32_t numberOfIterations=5) -> Image"""
    return _SimpleITK.CurvatureAnisotropicDiffusion(image1, timeStep, conductanceParameter, conductanceScalingUpdateInterval, numberOfIterations)
class CurvatureFlowImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::CurvatureFlowImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_CurvatureFlowImageFilter

    def __init__(self):
        r"""__init__(CurvatureFlowImageFilter self) -> CurvatureFlowImageFilter"""
        _SimpleITK.CurvatureFlowImageFilter_swiginit(self, _SimpleITK.new_CurvatureFlowImageFilter())

    def SetTimeStep(self, TimeStep):
        r"""SetTimeStep(CurvatureFlowImageFilter self, double TimeStep)"""
        return _SimpleITK.CurvatureFlowImageFilter_SetTimeStep(self, TimeStep)

    def GetTimeStep(self):
        r"""GetTimeStep(CurvatureFlowImageFilter self) -> double"""
        return _SimpleITK.CurvatureFlowImageFilter_GetTimeStep(self)

    def SetNumberOfIterations(self, NumberOfIterations):
        r"""SetNumberOfIterations(CurvatureFlowImageFilter self, uint32_t NumberOfIterations)"""
        return _SimpleITK.CurvatureFlowImageFilter_SetNumberOfIterations(self, NumberOfIterations)

    def GetNumberOfIterations(self):
        r"""GetNumberOfIterations(CurvatureFlowImageFilter self) -> uint32_t"""
        return _SimpleITK.CurvatureFlowImageFilter_GetNumberOfIterations(self)

    def GetName(self):
        r"""GetName(CurvatureFlowImageFilter self) -> std::string"""
        return _SimpleITK.CurvatureFlowImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(CurvatureFlowImageFilter self) -> std::string"""
        return _SimpleITK.CurvatureFlowImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(CurvatureFlowImageFilter self, Image image1) -> Image"""
        return _SimpleITK.CurvatureFlowImageFilter_Execute(self, image1)

# Register CurvatureFlowImageFilter in _SimpleITK:
_SimpleITK.CurvatureFlowImageFilter_swigregister(CurvatureFlowImageFilter)

def CurvatureFlow(image1, timeStep=0.05, numberOfIterations=5):
    r"""CurvatureFlow(Image image1, double timeStep=0.05, uint32_t numberOfIterations=5) -> Image"""
    return _SimpleITK.CurvatureFlow(image1, timeStep, numberOfIterations)
class CyclicShiftImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::CyclicShiftImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_CyclicShiftImageFilter

    def __init__(self):
        r"""__init__(CyclicShiftImageFilter self) -> CyclicShiftImageFilter"""
        _SimpleITK.CyclicShiftImageFilter_swiginit(self, _SimpleITK.new_CyclicShiftImageFilter())

    def SetShift(self, *args):
        r"""
        SetShift(CyclicShiftImageFilter self, VectorInt32 Shift)
        SetShift(CyclicShiftImageFilter self, int value)
        """
        return _SimpleITK.CyclicShiftImageFilter_SetShift(self, *args)

    def GetShift(self):
        r"""GetShift(CyclicShiftImageFilter self) -> VectorInt32"""
        return _SimpleITK.CyclicShiftImageFilter_GetShift(self)

    def GetName(self):
        r"""GetName(CyclicShiftImageFilter self) -> std::string"""
        return _SimpleITK.CyclicShiftImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(CyclicShiftImageFilter self) -> std::string"""
        return _SimpleITK.CyclicShiftImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(CyclicShiftImageFilter self, Image image1) -> Image"""
        return _SimpleITK.CyclicShiftImageFilter_Execute(self, image1)

# Register CyclicShiftImageFilter in _SimpleITK:
_SimpleITK.CyclicShiftImageFilter_swigregister(CyclicShiftImageFilter)

def CyclicShift(*args, **kwargs):
    r"""CyclicShift(Image image1, VectorInt32 shift=std::vector< int >(3, 0)) -> Image"""
    return _SimpleITK.CyclicShift(*args, **kwargs)
class DICOMOrientImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::DICOMOrientImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_DICOMOrientImageFilter

    def __init__(self):
        r"""__init__(DICOMOrientImageFilter self) -> DICOMOrientImageFilter"""
        _SimpleITK.DICOMOrientImageFilter_swiginit(self, _SimpleITK.new_DICOMOrientImageFilter())

    @staticmethod
    def GetOrientationFromDirectionCosines(direction):
        r"""GetOrientationFromDirectionCosines(VectorDouble direction) -> std::string"""
        return _SimpleITK.DICOMOrientImageFilter_GetOrientationFromDirectionCosines(direction)

    @staticmethod
    def GetDirectionCosinesFromOrientation(str):
        r"""GetDirectionCosinesFromOrientation(std::string const & str) -> VectorDouble"""
        return _SimpleITK.DICOMOrientImageFilter_GetDirectionCosinesFromOrientation(str)

    def SetDesiredCoordinateOrientation(self, DesiredCoordinateOrientation):
        r"""SetDesiredCoordinateOrientation(DICOMOrientImageFilter self, std::string DesiredCoordinateOrientation)"""
        return _SimpleITK.DICOMOrientImageFilter_SetDesiredCoordinateOrientation(self, DesiredCoordinateOrientation)

    def GetDesiredCoordinateOrientation(self):
        r"""GetDesiredCoordinateOrientation(DICOMOrientImageFilter self) -> std::string"""
        return _SimpleITK.DICOMOrientImageFilter_GetDesiredCoordinateOrientation(self)

    def GetFlipAxes(self):
        r"""GetFlipAxes(DICOMOrientImageFilter self) -> VectorBool"""
        return _SimpleITK.DICOMOrientImageFilter_GetFlipAxes(self)

    def GetPermuteOrder(self):
        r"""GetPermuteOrder(DICOMOrientImageFilter self) -> VectorUInt32"""
        return _SimpleITK.DICOMOrientImageFilter_GetPermuteOrder(self)

    def GetName(self):
        r"""GetName(DICOMOrientImageFilter self) -> std::string"""
        return _SimpleITK.DICOMOrientImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(DICOMOrientImageFilter self) -> std::string"""
        return _SimpleITK.DICOMOrientImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(DICOMOrientImageFilter self, Image image1) -> Image"""
        return _SimpleITK.DICOMOrientImageFilter_Execute(self, image1)

# Register DICOMOrientImageFilter in _SimpleITK:
_SimpleITK.DICOMOrientImageFilter_swigregister(DICOMOrientImageFilter)

def DICOMOrientImageFilter_GetOrientationFromDirectionCosines(direction):
    r"""DICOMOrientImageFilter_GetOrientationFromDirectionCosines(VectorDouble direction) -> std::string"""
    return _SimpleITK.DICOMOrientImageFilter_GetOrientationFromDirectionCosines(direction)

def DICOMOrientImageFilter_GetDirectionCosinesFromOrientation(str):
    r"""DICOMOrientImageFilter_GetDirectionCosinesFromOrientation(std::string const & str) -> VectorDouble"""
    return _SimpleITK.DICOMOrientImageFilter_GetDirectionCosinesFromOrientation(str)


def DICOMOrient(*args, **kwargs):
    r"""DICOMOrient(Image image1, std::string desiredCoordinateOrientation=std::string("LPS")) -> Image"""
    return _SimpleITK.DICOMOrient(*args, **kwargs)
class DanielssonDistanceMapImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::DanielssonDistanceMapImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_DanielssonDistanceMapImageFilter

    def __init__(self):
        r"""__init__(DanielssonDistanceMapImageFilter self) -> DanielssonDistanceMapImageFilter"""
        _SimpleITK.DanielssonDistanceMapImageFilter_swiginit(self, _SimpleITK.new_DanielssonDistanceMapImageFilter())

    def SetInputIsBinary(self, InputIsBinary):
        r"""SetInputIsBinary(DanielssonDistanceMapImageFilter self, bool InputIsBinary)"""
        return _SimpleITK.DanielssonDistanceMapImageFilter_SetInputIsBinary(self, InputIsBinary)

    def InputIsBinaryOn(self):
        r"""InputIsBinaryOn(DanielssonDistanceMapImageFilter self)"""
        return _SimpleITK.DanielssonDistanceMapImageFilter_InputIsBinaryOn(self)

    def InputIsBinaryOff(self):
        r"""InputIsBinaryOff(DanielssonDistanceMapImageFilter self)"""
        return _SimpleITK.DanielssonDistanceMapImageFilter_InputIsBinaryOff(self)

    def GetInputIsBinary(self):
        r"""GetInputIsBinary(DanielssonDistanceMapImageFilter self) -> bool"""
        return _SimpleITK.DanielssonDistanceMapImageFilter_GetInputIsBinary(self)

    def SetSquaredDistance(self, SquaredDistance):
        r"""SetSquaredDistance(DanielssonDistanceMapImageFilter self, bool SquaredDistance)"""
        return _SimpleITK.DanielssonDistanceMapImageFilter_SetSquaredDistance(self, SquaredDistance)

    def SquaredDistanceOn(self):
        r"""SquaredDistanceOn(DanielssonDistanceMapImageFilter self)"""
        return _SimpleITK.DanielssonDistanceMapImageFilter_SquaredDistanceOn(self)

    def SquaredDistanceOff(self):
        r"""SquaredDistanceOff(DanielssonDistanceMapImageFilter self)"""
        return _SimpleITK.DanielssonDistanceMapImageFilter_SquaredDistanceOff(self)

    def GetSquaredDistance(self):
        r"""GetSquaredDistance(DanielssonDistanceMapImageFilter self) -> bool"""
        return _SimpleITK.DanielssonDistanceMapImageFilter_GetSquaredDistance(self)

    def SetUseImageSpacing(self, UseImageSpacing):
        r"""SetUseImageSpacing(DanielssonDistanceMapImageFilter self, bool UseImageSpacing)"""
        return _SimpleITK.DanielssonDistanceMapImageFilter_SetUseImageSpacing(self, UseImageSpacing)

    def UseImageSpacingOn(self):
        r"""UseImageSpacingOn(DanielssonDistanceMapImageFilter self)"""
        return _SimpleITK.DanielssonDistanceMapImageFilter_UseImageSpacingOn(self)

    def UseImageSpacingOff(self):
        r"""UseImageSpacingOff(DanielssonDistanceMapImageFilter self)"""
        return _SimpleITK.DanielssonDistanceMapImageFilter_UseImageSpacingOff(self)

    def GetUseImageSpacing(self):
        r"""GetUseImageSpacing(DanielssonDistanceMapImageFilter self) -> bool"""
        return _SimpleITK.DanielssonDistanceMapImageFilter_GetUseImageSpacing(self)

    def GetVoronoiMap(self):
        r"""GetVoronoiMap(DanielssonDistanceMapImageFilter self) -> Image"""
        return _SimpleITK.DanielssonDistanceMapImageFilter_GetVoronoiMap(self)

    def GetVectorDistanceMap(self):
        r"""GetVectorDistanceMap(DanielssonDistanceMapImageFilter self) -> Image"""
        return _SimpleITK.DanielssonDistanceMapImageFilter_GetVectorDistanceMap(self)

    def GetName(self):
        r"""GetName(DanielssonDistanceMapImageFilter self) -> std::string"""
        return _SimpleITK.DanielssonDistanceMapImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(DanielssonDistanceMapImageFilter self) -> std::string"""
        return _SimpleITK.DanielssonDistanceMapImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(DanielssonDistanceMapImageFilter self, Image image1) -> Image"""
        return _SimpleITK.DanielssonDistanceMapImageFilter_Execute(self, image1)

# Register DanielssonDistanceMapImageFilter in _SimpleITK:
_SimpleITK.DanielssonDistanceMapImageFilter_swigregister(DanielssonDistanceMapImageFilter)

def DanielssonDistanceMap(image1, inputIsBinary=False, squaredDistance=False, useImageSpacing=False):
    r"""DanielssonDistanceMap(Image image1, bool inputIsBinary=False, bool squaredDistance=False, bool useImageSpacing=False) -> Image"""
    return _SimpleITK.DanielssonDistanceMap(image1, inputIsBinary, squaredDistance, useImageSpacing)
class DemonsRegistrationFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::DemonsRegistrationFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_DemonsRegistrationFilter

    def __init__(self):
        r"""__init__(DemonsRegistrationFilter self) -> DemonsRegistrationFilter"""
        _SimpleITK.DemonsRegistrationFilter_swiginit(self, _SimpleITK.new_DemonsRegistrationFilter())

    def SetStandardDeviations(self, *args):
        r"""
        SetStandardDeviations(DemonsRegistrationFilter self, VectorDouble StandardDeviations)
        SetStandardDeviations(DemonsRegistrationFilter self, double value)
        """
        return _SimpleITK.DemonsRegistrationFilter_SetStandardDeviations(self, *args)

    def GetStandardDeviations(self):
        r"""GetStandardDeviations(DemonsRegistrationFilter self) -> VectorDouble"""
        return _SimpleITK.DemonsRegistrationFilter_GetStandardDeviations(self)

    def SetNumberOfIterations(self, NumberOfIterations):
        r"""SetNumberOfIterations(DemonsRegistrationFilter self, uint32_t NumberOfIterations)"""
        return _SimpleITK.DemonsRegistrationFilter_SetNumberOfIterations(self, NumberOfIterations)

    def GetNumberOfIterations(self):
        r"""GetNumberOfIterations(DemonsRegistrationFilter self) -> uint32_t"""
        return _SimpleITK.DemonsRegistrationFilter_GetNumberOfIterations(self)

    def SetMaximumRMSError(self, MaximumRMSError):
        r"""SetMaximumRMSError(DemonsRegistrationFilter self, double MaximumRMSError)"""
        return _SimpleITK.DemonsRegistrationFilter_SetMaximumRMSError(self, MaximumRMSError)

    def GetMaximumRMSError(self):
        r"""GetMaximumRMSError(DemonsRegistrationFilter self) -> double"""
        return _SimpleITK.DemonsRegistrationFilter_GetMaximumRMSError(self)

    def SetUseMovingImageGradient(self, UseMovingImageGradient):
        r"""SetUseMovingImageGradient(DemonsRegistrationFilter self, bool UseMovingImageGradient)"""
        return _SimpleITK.DemonsRegistrationFilter_SetUseMovingImageGradient(self, UseMovingImageGradient)

    def UseMovingImageGradientOn(self):
        r"""UseMovingImageGradientOn(DemonsRegistrationFilter self)"""
        return _SimpleITK.DemonsRegistrationFilter_UseMovingImageGradientOn(self)

    def UseMovingImageGradientOff(self):
        r"""UseMovingImageGradientOff(DemonsRegistrationFilter self)"""
        return _SimpleITK.DemonsRegistrationFilter_UseMovingImageGradientOff(self)

    def GetUseMovingImageGradient(self):
        r"""GetUseMovingImageGradient(DemonsRegistrationFilter self) -> bool"""
        return _SimpleITK.DemonsRegistrationFilter_GetUseMovingImageGradient(self)

    def SetSmoothDisplacementField(self, SmoothDisplacementField):
        r"""SetSmoothDisplacementField(DemonsRegistrationFilter self, bool SmoothDisplacementField)"""
        return _SimpleITK.DemonsRegistrationFilter_SetSmoothDisplacementField(self, SmoothDisplacementField)

    def SmoothDisplacementFieldOn(self):
        r"""SmoothDisplacementFieldOn(DemonsRegistrationFilter self)"""
        return _SimpleITK.DemonsRegistrationFilter_SmoothDisplacementFieldOn(self)

    def SmoothDisplacementFieldOff(self):
        r"""SmoothDisplacementFieldOff(DemonsRegistrationFilter self)"""
        return _SimpleITK.DemonsRegistrationFilter_SmoothDisplacementFieldOff(self)

    def GetSmoothDisplacementField(self):
        r"""GetSmoothDisplacementField(DemonsRegistrationFilter self) -> bool"""
        return _SimpleITK.DemonsRegistrationFilter_GetSmoothDisplacementField(self)

    def SetSmoothUpdateField(self, SmoothUpdateField):
        r"""SetSmoothUpdateField(DemonsRegistrationFilter self, bool SmoothUpdateField)"""
        return _SimpleITK.DemonsRegistrationFilter_SetSmoothUpdateField(self, SmoothUpdateField)

    def SmoothUpdateFieldOn(self):
        r"""SmoothUpdateFieldOn(DemonsRegistrationFilter self)"""
        return _SimpleITK.DemonsRegistrationFilter_SmoothUpdateFieldOn(self)

    def SmoothUpdateFieldOff(self):
        r"""SmoothUpdateFieldOff(DemonsRegistrationFilter self)"""
        return _SimpleITK.DemonsRegistrationFilter_SmoothUpdateFieldOff(self)

    def GetSmoothUpdateField(self):
        r"""GetSmoothUpdateField(DemonsRegistrationFilter self) -> bool"""
        return _SimpleITK.DemonsRegistrationFilter_GetSmoothUpdateField(self)

    def SetUpdateFieldStandardDeviations(self, *args):
        r"""
        SetUpdateFieldStandardDeviations(DemonsRegistrationFilter self, VectorDouble UpdateFieldStandardDeviations)
        SetUpdateFieldStandardDeviations(DemonsRegistrationFilter self, double value)
        """
        return _SimpleITK.DemonsRegistrationFilter_SetUpdateFieldStandardDeviations(self, *args)

    def GetUpdateFieldStandardDeviations(self):
        r"""GetUpdateFieldStandardDeviations(DemonsRegistrationFilter self) -> VectorDouble"""
        return _SimpleITK.DemonsRegistrationFilter_GetUpdateFieldStandardDeviations(self)

    def SetMaximumKernelWidth(self, MaximumKernelWidth):
        r"""SetMaximumKernelWidth(DemonsRegistrationFilter self, unsigned int MaximumKernelWidth)"""
        return _SimpleITK.DemonsRegistrationFilter_SetMaximumKernelWidth(self, MaximumKernelWidth)

    def GetMaximumKernelWidth(self):
        r"""GetMaximumKernelWidth(DemonsRegistrationFilter self) -> unsigned int"""
        return _SimpleITK.DemonsRegistrationFilter_GetMaximumKernelWidth(self)

    def SetMaximumError(self, MaximumError):
        r"""SetMaximumError(DemonsRegistrationFilter self, double MaximumError)"""
        return _SimpleITK.DemonsRegistrationFilter_SetMaximumError(self, MaximumError)

    def GetMaximumError(self):
        r"""GetMaximumError(DemonsRegistrationFilter self) -> double"""
        return _SimpleITK.DemonsRegistrationFilter_GetMaximumError(self)

    def SetIntensityDifferenceThreshold(self, IntensityDifferenceThreshold):
        r"""SetIntensityDifferenceThreshold(DemonsRegistrationFilter self, double IntensityDifferenceThreshold)"""
        return _SimpleITK.DemonsRegistrationFilter_SetIntensityDifferenceThreshold(self, IntensityDifferenceThreshold)

    def GetIntensityDifferenceThreshold(self):
        r"""GetIntensityDifferenceThreshold(DemonsRegistrationFilter self) -> double"""
        return _SimpleITK.DemonsRegistrationFilter_GetIntensityDifferenceThreshold(self)

    def SetUseImageSpacing(self, UseImageSpacing):
        r"""SetUseImageSpacing(DemonsRegistrationFilter self, bool UseImageSpacing)"""
        return _SimpleITK.DemonsRegistrationFilter_SetUseImageSpacing(self, UseImageSpacing)

    def UseImageSpacingOn(self):
        r"""UseImageSpacingOn(DemonsRegistrationFilter self)"""
        return _SimpleITK.DemonsRegistrationFilter_UseImageSpacingOn(self)

    def UseImageSpacingOff(self):
        r"""UseImageSpacingOff(DemonsRegistrationFilter self)"""
        return _SimpleITK.DemonsRegistrationFilter_UseImageSpacingOff(self)

    def GetUseImageSpacing(self):
        r"""GetUseImageSpacing(DemonsRegistrationFilter self) -> bool"""
        return _SimpleITK.DemonsRegistrationFilter_GetUseImageSpacing(self)

    def GetElapsedIterations(self):
        r"""GetElapsedIterations(DemonsRegistrationFilter self) -> uint32_t"""
        return _SimpleITK.DemonsRegistrationFilter_GetElapsedIterations(self)

    def GetRMSChange(self):
        r"""GetRMSChange(DemonsRegistrationFilter self) -> double"""
        return _SimpleITK.DemonsRegistrationFilter_GetRMSChange(self)

    def GetMetric(self):
        r"""GetMetric(DemonsRegistrationFilter self) -> double"""
        return _SimpleITK.DemonsRegistrationFilter_GetMetric(self)

    def StopRegistration(self):
        r"""StopRegistration(DemonsRegistrationFilter self)"""
        return _SimpleITK.DemonsRegistrationFilter_StopRegistration(self)

    def GetName(self):
        r"""GetName(DemonsRegistrationFilter self) -> std::string"""
        return _SimpleITK.DemonsRegistrationFilter_GetName(self)

    def __str__(self):
        r"""__str__(DemonsRegistrationFilter self) -> std::string"""
        return _SimpleITK.DemonsRegistrationFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(DemonsRegistrationFilter self, Image fixedImage, Image movingImage, Image initialDisplacementField) -> Image
        Execute(DemonsRegistrationFilter self, Image fixedImage, Image movingImage) -> Image
        """
        return _SimpleITK.DemonsRegistrationFilter_Execute(self, *args)

# Register DemonsRegistrationFilter in _SimpleITK:
_SimpleITK.DemonsRegistrationFilter_swigregister(DemonsRegistrationFilter)
class DerivativeImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::DerivativeImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_DerivativeImageFilter

    def __init__(self):
        r"""__init__(DerivativeImageFilter self) -> DerivativeImageFilter"""
        _SimpleITK.DerivativeImageFilter_swiginit(self, _SimpleITK.new_DerivativeImageFilter())

    def SetDirection(self, Direction):
        r"""SetDirection(DerivativeImageFilter self, unsigned int Direction)"""
        return _SimpleITK.DerivativeImageFilter_SetDirection(self, Direction)

    def GetDirection(self):
        r"""GetDirection(DerivativeImageFilter self) -> unsigned int"""
        return _SimpleITK.DerivativeImageFilter_GetDirection(self)

    def SetOrder(self, Order):
        r"""SetOrder(DerivativeImageFilter self, unsigned int Order)"""
        return _SimpleITK.DerivativeImageFilter_SetOrder(self, Order)

    def GetOrder(self):
        r"""GetOrder(DerivativeImageFilter self) -> unsigned int"""
        return _SimpleITK.DerivativeImageFilter_GetOrder(self)

    def SetUseImageSpacing(self, UseImageSpacing):
        r"""SetUseImageSpacing(DerivativeImageFilter self, bool UseImageSpacing)"""
        return _SimpleITK.DerivativeImageFilter_SetUseImageSpacing(self, UseImageSpacing)

    def UseImageSpacingOn(self):
        r"""UseImageSpacingOn(DerivativeImageFilter self)"""
        return _SimpleITK.DerivativeImageFilter_UseImageSpacingOn(self)

    def UseImageSpacingOff(self):
        r"""UseImageSpacingOff(DerivativeImageFilter self)"""
        return _SimpleITK.DerivativeImageFilter_UseImageSpacingOff(self)

    def GetUseImageSpacing(self):
        r"""GetUseImageSpacing(DerivativeImageFilter self) -> bool"""
        return _SimpleITK.DerivativeImageFilter_GetUseImageSpacing(self)

    def GetName(self):
        r"""GetName(DerivativeImageFilter self) -> std::string"""
        return _SimpleITK.DerivativeImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(DerivativeImageFilter self) -> std::string"""
        return _SimpleITK.DerivativeImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(DerivativeImageFilter self, Image image1) -> Image"""
        return _SimpleITK.DerivativeImageFilter_Execute(self, image1)

# Register DerivativeImageFilter in _SimpleITK:
_SimpleITK.DerivativeImageFilter_swigregister(DerivativeImageFilter)

def Derivative(image1, direction=0, order=1, useImageSpacing=True):
    r"""Derivative(Image image1, unsigned int direction=0, unsigned int order=1, bool useImageSpacing=True) -> Image"""
    return _SimpleITK.Derivative(image1, direction, order, useImageSpacing)
class DiffeomorphicDemonsRegistrationFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::DiffeomorphicDemonsRegistrationFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_DiffeomorphicDemonsRegistrationFilter

    def __init__(self):
        r"""__init__(DiffeomorphicDemonsRegistrationFilter self) -> DiffeomorphicDemonsRegistrationFilter"""
        _SimpleITK.DiffeomorphicDemonsRegistrationFilter_swiginit(self, _SimpleITK.new_DiffeomorphicDemonsRegistrationFilter())

    def SetStandardDeviations(self, *args):
        r"""
        SetStandardDeviations(DiffeomorphicDemonsRegistrationFilter self, VectorDouble StandardDeviations)
        SetStandardDeviations(DiffeomorphicDemonsRegistrationFilter self, double value)
        """
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_SetStandardDeviations(self, *args)

    def GetStandardDeviations(self):
        r"""GetStandardDeviations(DiffeomorphicDemonsRegistrationFilter self) -> VectorDouble"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_GetStandardDeviations(self)

    def SetNumberOfIterations(self, NumberOfIterations):
        r"""SetNumberOfIterations(DiffeomorphicDemonsRegistrationFilter self, uint32_t NumberOfIterations)"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_SetNumberOfIterations(self, NumberOfIterations)

    def GetNumberOfIterations(self):
        r"""GetNumberOfIterations(DiffeomorphicDemonsRegistrationFilter self) -> uint32_t"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_GetNumberOfIterations(self)

    def SetMaximumRMSError(self, MaximumRMSError):
        r"""SetMaximumRMSError(DiffeomorphicDemonsRegistrationFilter self, double MaximumRMSError)"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_SetMaximumRMSError(self, MaximumRMSError)

    def GetMaximumRMSError(self):
        r"""GetMaximumRMSError(DiffeomorphicDemonsRegistrationFilter self) -> double"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_GetMaximumRMSError(self)
    Symmetric = _SimpleITK.DiffeomorphicDemonsRegistrationFilter_Symmetric
    
    Fixed = _SimpleITK.DiffeomorphicDemonsRegistrationFilter_Fixed
    
    WarpedMoving = _SimpleITK.DiffeomorphicDemonsRegistrationFilter_WarpedMoving
    
    MappedMoving = _SimpleITK.DiffeomorphicDemonsRegistrationFilter_MappedMoving
    

    def SetUseGradientType(self, UseGradientType):
        r"""SetUseGradientType(DiffeomorphicDemonsRegistrationFilter self, slicer_itk::simple::DiffeomorphicDemonsRegistrationFilter::UseGradientTypeType UseGradientType)"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_SetUseGradientType(self, UseGradientType)

    def GetUseGradientType(self):
        r"""GetUseGradientType(DiffeomorphicDemonsRegistrationFilter self) -> slicer_itk::simple::DiffeomorphicDemonsRegistrationFilter::UseGradientTypeType"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_GetUseGradientType(self)

    def SetUseFirstOrderExp(self, UseFirstOrderExp):
        r"""SetUseFirstOrderExp(DiffeomorphicDemonsRegistrationFilter self, bool UseFirstOrderExp)"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_SetUseFirstOrderExp(self, UseFirstOrderExp)

    def UseFirstOrderExpOn(self):
        r"""UseFirstOrderExpOn(DiffeomorphicDemonsRegistrationFilter self)"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_UseFirstOrderExpOn(self)

    def UseFirstOrderExpOff(self):
        r"""UseFirstOrderExpOff(DiffeomorphicDemonsRegistrationFilter self)"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_UseFirstOrderExpOff(self)

    def GetUseFirstOrderExp(self):
        r"""GetUseFirstOrderExp(DiffeomorphicDemonsRegistrationFilter self) -> bool"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_GetUseFirstOrderExp(self)

    def SetMaximumUpdateStepLength(self, MaximumUpdateStepLength):
        r"""SetMaximumUpdateStepLength(DiffeomorphicDemonsRegistrationFilter self, double MaximumUpdateStepLength)"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_SetMaximumUpdateStepLength(self, MaximumUpdateStepLength)

    def GetMaximumUpdateStepLength(self):
        r"""GetMaximumUpdateStepLength(DiffeomorphicDemonsRegistrationFilter self) -> double"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_GetMaximumUpdateStepLength(self)

    def SetSmoothDisplacementField(self, SmoothDisplacementField):
        r"""SetSmoothDisplacementField(DiffeomorphicDemonsRegistrationFilter self, bool SmoothDisplacementField)"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_SetSmoothDisplacementField(self, SmoothDisplacementField)

    def SmoothDisplacementFieldOn(self):
        r"""SmoothDisplacementFieldOn(DiffeomorphicDemonsRegistrationFilter self)"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_SmoothDisplacementFieldOn(self)

    def SmoothDisplacementFieldOff(self):
        r"""SmoothDisplacementFieldOff(DiffeomorphicDemonsRegistrationFilter self)"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_SmoothDisplacementFieldOff(self)

    def GetSmoothDisplacementField(self):
        r"""GetSmoothDisplacementField(DiffeomorphicDemonsRegistrationFilter self) -> bool"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_GetSmoothDisplacementField(self)

    def SetSmoothUpdateField(self, SmoothUpdateField):
        r"""SetSmoothUpdateField(DiffeomorphicDemonsRegistrationFilter self, bool SmoothUpdateField)"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_SetSmoothUpdateField(self, SmoothUpdateField)

    def SmoothUpdateFieldOn(self):
        r"""SmoothUpdateFieldOn(DiffeomorphicDemonsRegistrationFilter self)"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_SmoothUpdateFieldOn(self)

    def SmoothUpdateFieldOff(self):
        r"""SmoothUpdateFieldOff(DiffeomorphicDemonsRegistrationFilter self)"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_SmoothUpdateFieldOff(self)

    def GetSmoothUpdateField(self):
        r"""GetSmoothUpdateField(DiffeomorphicDemonsRegistrationFilter self) -> bool"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_GetSmoothUpdateField(self)

    def SetUpdateFieldStandardDeviations(self, *args):
        r"""
        SetUpdateFieldStandardDeviations(DiffeomorphicDemonsRegistrationFilter self, VectorDouble UpdateFieldStandardDeviations)
        SetUpdateFieldStandardDeviations(DiffeomorphicDemonsRegistrationFilter self, double value)
        """
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_SetUpdateFieldStandardDeviations(self, *args)

    def GetUpdateFieldStandardDeviations(self):
        r"""GetUpdateFieldStandardDeviations(DiffeomorphicDemonsRegistrationFilter self) -> VectorDouble"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_GetUpdateFieldStandardDeviations(self)

    def SetMaximumKernelWidth(self, MaximumKernelWidth):
        r"""SetMaximumKernelWidth(DiffeomorphicDemonsRegistrationFilter self, unsigned int MaximumKernelWidth)"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_SetMaximumKernelWidth(self, MaximumKernelWidth)

    def GetMaximumKernelWidth(self):
        r"""GetMaximumKernelWidth(DiffeomorphicDemonsRegistrationFilter self) -> unsigned int"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_GetMaximumKernelWidth(self)

    def SetMaximumError(self, MaximumError):
        r"""SetMaximumError(DiffeomorphicDemonsRegistrationFilter self, double MaximumError)"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_SetMaximumError(self, MaximumError)

    def GetMaximumError(self):
        r"""GetMaximumError(DiffeomorphicDemonsRegistrationFilter self) -> double"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_GetMaximumError(self)

    def SetIntensityDifferenceThreshold(self, IntensityDifferenceThreshold):
        r"""SetIntensityDifferenceThreshold(DiffeomorphicDemonsRegistrationFilter self, double IntensityDifferenceThreshold)"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_SetIntensityDifferenceThreshold(self, IntensityDifferenceThreshold)

    def GetIntensityDifferenceThreshold(self):
        r"""GetIntensityDifferenceThreshold(DiffeomorphicDemonsRegistrationFilter self) -> double"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_GetIntensityDifferenceThreshold(self)

    def SetUseImageSpacing(self, UseImageSpacing):
        r"""SetUseImageSpacing(DiffeomorphicDemonsRegistrationFilter self, bool UseImageSpacing)"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_SetUseImageSpacing(self, UseImageSpacing)

    def UseImageSpacingOn(self):
        r"""UseImageSpacingOn(DiffeomorphicDemonsRegistrationFilter self)"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_UseImageSpacingOn(self)

    def UseImageSpacingOff(self):
        r"""UseImageSpacingOff(DiffeomorphicDemonsRegistrationFilter self)"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_UseImageSpacingOff(self)

    def GetUseImageSpacing(self):
        r"""GetUseImageSpacing(DiffeomorphicDemonsRegistrationFilter self) -> bool"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_GetUseImageSpacing(self)

    def GetElapsedIterations(self):
        r"""GetElapsedIterations(DiffeomorphicDemonsRegistrationFilter self) -> uint32_t"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_GetElapsedIterations(self)

    def GetRMSChange(self):
        r"""GetRMSChange(DiffeomorphicDemonsRegistrationFilter self) -> double"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_GetRMSChange(self)

    def GetMetric(self):
        r"""GetMetric(DiffeomorphicDemonsRegistrationFilter self) -> double"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_GetMetric(self)

    def StopRegistration(self):
        r"""StopRegistration(DiffeomorphicDemonsRegistrationFilter self)"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_StopRegistration(self)

    def GetName(self):
        r"""GetName(DiffeomorphicDemonsRegistrationFilter self) -> std::string"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_GetName(self)

    def __str__(self):
        r"""__str__(DiffeomorphicDemonsRegistrationFilter self) -> std::string"""
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(DiffeomorphicDemonsRegistrationFilter self, Image fixedImage, Image movingImage, Image initialDisplacementField) -> Image
        Execute(DiffeomorphicDemonsRegistrationFilter self, Image fixedImage, Image movingImage) -> Image
        """
        return _SimpleITK.DiffeomorphicDemonsRegistrationFilter_Execute(self, *args)

# Register DiffeomorphicDemonsRegistrationFilter in _SimpleITK:
_SimpleITK.DiffeomorphicDemonsRegistrationFilter_swigregister(DiffeomorphicDemonsRegistrationFilter)
class DilateObjectMorphologyImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::DilateObjectMorphologyImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_DilateObjectMorphologyImageFilter

    def __init__(self):
        r"""__init__(DilateObjectMorphologyImageFilter self) -> DilateObjectMorphologyImageFilter"""
        _SimpleITK.DilateObjectMorphologyImageFilter_swiginit(self, _SimpleITK.new_DilateObjectMorphologyImageFilter())

    def SetKernelRadius(self, *args):
        r"""
        SetKernelRadius(DilateObjectMorphologyImageFilter self, VectorUInt32 KernelRadius)
        SetKernelRadius(DilateObjectMorphologyImageFilter self, unsigned int value)
        """
        return _SimpleITK.DilateObjectMorphologyImageFilter_SetKernelRadius(self, *args)

    def GetKernelRadius(self):
        r"""GetKernelRadius(DilateObjectMorphologyImageFilter self) -> VectorUInt32"""
        return _SimpleITK.DilateObjectMorphologyImageFilter_GetKernelRadius(self)

    def SetKernelType(self, KernelType):
        r"""SetKernelType(DilateObjectMorphologyImageFilter self, slicer_itk::simple::KernelEnum KernelType)"""
        return _SimpleITK.DilateObjectMorphologyImageFilter_SetKernelType(self, KernelType)

    def GetKernelType(self):
        r"""GetKernelType(DilateObjectMorphologyImageFilter self) -> slicer_itk::simple::KernelEnum"""
        return _SimpleITK.DilateObjectMorphologyImageFilter_GetKernelType(self)

    def SetObjectValue(self, ObjectValue):
        r"""SetObjectValue(DilateObjectMorphologyImageFilter self, double ObjectValue)"""
        return _SimpleITK.DilateObjectMorphologyImageFilter_SetObjectValue(self, ObjectValue)

    def GetObjectValue(self):
        r"""GetObjectValue(DilateObjectMorphologyImageFilter self) -> double"""
        return _SimpleITK.DilateObjectMorphologyImageFilter_GetObjectValue(self)

    def GetName(self):
        r"""GetName(DilateObjectMorphologyImageFilter self) -> std::string"""
        return _SimpleITK.DilateObjectMorphologyImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(DilateObjectMorphologyImageFilter self) -> std::string"""
        return _SimpleITK.DilateObjectMorphologyImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(DilateObjectMorphologyImageFilter self, Image image1) -> Image"""
        return _SimpleITK.DilateObjectMorphologyImageFilter_Execute(self, image1)

# Register DilateObjectMorphologyImageFilter in _SimpleITK:
_SimpleITK.DilateObjectMorphologyImageFilter_swigregister(DilateObjectMorphologyImageFilter)

def DilateObjectMorphology(*args, **kwargs):
    r"""DilateObjectMorphology(Image image1, VectorUInt32 kernelRadius=std::vector< uint32_t >(3, 1), slicer_itk::simple::KernelEnum kernelType=sitkBall, double objectValue=1) -> Image"""
    return _SimpleITK.DilateObjectMorphology(*args, **kwargs)
class DiscreteGaussianDerivativeImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::DiscreteGaussianDerivativeImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_DiscreteGaussianDerivativeImageFilter

    def __init__(self):
        r"""__init__(DiscreteGaussianDerivativeImageFilter self) -> DiscreteGaussianDerivativeImageFilter"""
        _SimpleITK.DiscreteGaussianDerivativeImageFilter_swiginit(self, _SimpleITK.new_DiscreteGaussianDerivativeImageFilter())

    def SetVariance(self, *args):
        r"""
        SetVariance(DiscreteGaussianDerivativeImageFilter self, VectorDouble Variance)
        SetVariance(DiscreteGaussianDerivativeImageFilter self, double value)
        """
        return _SimpleITK.DiscreteGaussianDerivativeImageFilter_SetVariance(self, *args)

    def GetVariance(self):
        r"""GetVariance(DiscreteGaussianDerivativeImageFilter self) -> VectorDouble"""
        return _SimpleITK.DiscreteGaussianDerivativeImageFilter_GetVariance(self)

    def SetOrder(self, *args):
        r"""
        SetOrder(DiscreteGaussianDerivativeImageFilter self, VectorUInt32 Order)
        SetOrder(DiscreteGaussianDerivativeImageFilter self, unsigned int value)
        """
        return _SimpleITK.DiscreteGaussianDerivativeImageFilter_SetOrder(self, *args)

    def GetOrder(self):
        r"""GetOrder(DiscreteGaussianDerivativeImageFilter self) -> VectorUInt32"""
        return _SimpleITK.DiscreteGaussianDerivativeImageFilter_GetOrder(self)

    def SetMaximumKernelWidth(self, MaximumKernelWidth):
        r"""SetMaximumKernelWidth(DiscreteGaussianDerivativeImageFilter self, unsigned int MaximumKernelWidth)"""
        return _SimpleITK.DiscreteGaussianDerivativeImageFilter_SetMaximumKernelWidth(self, MaximumKernelWidth)

    def GetMaximumKernelWidth(self):
        r"""GetMaximumKernelWidth(DiscreteGaussianDerivativeImageFilter self) -> unsigned int"""
        return _SimpleITK.DiscreteGaussianDerivativeImageFilter_GetMaximumKernelWidth(self)

    def SetMaximumError(self, MaximumError):
        r"""SetMaximumError(DiscreteGaussianDerivativeImageFilter self, double MaximumError)"""
        return _SimpleITK.DiscreteGaussianDerivativeImageFilter_SetMaximumError(self, MaximumError)

    def GetMaximumError(self):
        r"""GetMaximumError(DiscreteGaussianDerivativeImageFilter self) -> double"""
        return _SimpleITK.DiscreteGaussianDerivativeImageFilter_GetMaximumError(self)

    def SetUseImageSpacing(self, UseImageSpacing):
        r"""SetUseImageSpacing(DiscreteGaussianDerivativeImageFilter self, bool UseImageSpacing)"""
        return _SimpleITK.DiscreteGaussianDerivativeImageFilter_SetUseImageSpacing(self, UseImageSpacing)

    def UseImageSpacingOn(self):
        r"""UseImageSpacingOn(DiscreteGaussianDerivativeImageFilter self)"""
        return _SimpleITK.DiscreteGaussianDerivativeImageFilter_UseImageSpacingOn(self)

    def UseImageSpacingOff(self):
        r"""UseImageSpacingOff(DiscreteGaussianDerivativeImageFilter self)"""
        return _SimpleITK.DiscreteGaussianDerivativeImageFilter_UseImageSpacingOff(self)

    def GetUseImageSpacing(self):
        r"""GetUseImageSpacing(DiscreteGaussianDerivativeImageFilter self) -> bool"""
        return _SimpleITK.DiscreteGaussianDerivativeImageFilter_GetUseImageSpacing(self)

    def SetNormalizeAcrossScale(self, NormalizeAcrossScale):
        r"""SetNormalizeAcrossScale(DiscreteGaussianDerivativeImageFilter self, bool NormalizeAcrossScale)"""
        return _SimpleITK.DiscreteGaussianDerivativeImageFilter_SetNormalizeAcrossScale(self, NormalizeAcrossScale)

    def NormalizeAcrossScaleOn(self):
        r"""NormalizeAcrossScaleOn(DiscreteGaussianDerivativeImageFilter self)"""
        return _SimpleITK.DiscreteGaussianDerivativeImageFilter_NormalizeAcrossScaleOn(self)

    def NormalizeAcrossScaleOff(self):
        r"""NormalizeAcrossScaleOff(DiscreteGaussianDerivativeImageFilter self)"""
        return _SimpleITK.DiscreteGaussianDerivativeImageFilter_NormalizeAcrossScaleOff(self)

    def GetNormalizeAcrossScale(self):
        r"""GetNormalizeAcrossScale(DiscreteGaussianDerivativeImageFilter self) -> bool"""
        return _SimpleITK.DiscreteGaussianDerivativeImageFilter_GetNormalizeAcrossScale(self)

    def GetName(self):
        r"""GetName(DiscreteGaussianDerivativeImageFilter self) -> std::string"""
        return _SimpleITK.DiscreteGaussianDerivativeImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(DiscreteGaussianDerivativeImageFilter self) -> std::string"""
        return _SimpleITK.DiscreteGaussianDerivativeImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(DiscreteGaussianDerivativeImageFilter self, Image image1) -> Image"""
        return _SimpleITK.DiscreteGaussianDerivativeImageFilter_Execute(self, image1)

# Register DiscreteGaussianDerivativeImageFilter in _SimpleITK:
_SimpleITK.DiscreteGaussianDerivativeImageFilter_swigregister(DiscreteGaussianDerivativeImageFilter)

def DiscreteGaussianDerivative(*args, **kwargs):
    r"""DiscreteGaussianDerivative(Image image1, VectorDouble variance=std::vector< double >(3, 0.0), VectorUInt32 order=std::vector< unsigned int >(3, 1), unsigned int maximumKernelWidth=32, double maximumError=0.01, bool useImageSpacing=True, bool normalizeAcrossScale=False) -> Image"""
    return _SimpleITK.DiscreteGaussianDerivative(*args, **kwargs)
class DiscreteGaussianImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::DiscreteGaussianImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_DiscreteGaussianImageFilter

    def __init__(self):
        r"""__init__(DiscreteGaussianImageFilter self) -> DiscreteGaussianImageFilter"""
        _SimpleITK.DiscreteGaussianImageFilter_swiginit(self, _SimpleITK.new_DiscreteGaussianImageFilter())

    def SetVariance(self, *args):
        r"""
        SetVariance(DiscreteGaussianImageFilter self, VectorDouble Variance)
        SetVariance(DiscreteGaussianImageFilter self, double value)
        """
        return _SimpleITK.DiscreteGaussianImageFilter_SetVariance(self, *args)

    def GetVariance(self):
        r"""GetVariance(DiscreteGaussianImageFilter self) -> VectorDouble"""
        return _SimpleITK.DiscreteGaussianImageFilter_GetVariance(self)

    def SetMaximumKernelWidth(self, MaximumKernelWidth):
        r"""SetMaximumKernelWidth(DiscreteGaussianImageFilter self, unsigned int MaximumKernelWidth)"""
        return _SimpleITK.DiscreteGaussianImageFilter_SetMaximumKernelWidth(self, MaximumKernelWidth)

    def GetMaximumKernelWidth(self):
        r"""GetMaximumKernelWidth(DiscreteGaussianImageFilter self) -> unsigned int"""
        return _SimpleITK.DiscreteGaussianImageFilter_GetMaximumKernelWidth(self)

    def SetMaximumError(self, *args):
        r"""
        SetMaximumError(DiscreteGaussianImageFilter self, VectorDouble MaximumError)
        SetMaximumError(DiscreteGaussianImageFilter self, double value)
        """
        return _SimpleITK.DiscreteGaussianImageFilter_SetMaximumError(self, *args)

    def GetMaximumError(self):
        r"""GetMaximumError(DiscreteGaussianImageFilter self) -> VectorDouble"""
        return _SimpleITK.DiscreteGaussianImageFilter_GetMaximumError(self)

    def SetUseImageSpacing(self, UseImageSpacing):
        r"""SetUseImageSpacing(DiscreteGaussianImageFilter self, bool UseImageSpacing)"""
        return _SimpleITK.DiscreteGaussianImageFilter_SetUseImageSpacing(self, UseImageSpacing)

    def UseImageSpacingOn(self):
        r"""UseImageSpacingOn(DiscreteGaussianImageFilter self)"""
        return _SimpleITK.DiscreteGaussianImageFilter_UseImageSpacingOn(self)

    def UseImageSpacingOff(self):
        r"""UseImageSpacingOff(DiscreteGaussianImageFilter self)"""
        return _SimpleITK.DiscreteGaussianImageFilter_UseImageSpacingOff(self)

    def GetUseImageSpacing(self):
        r"""GetUseImageSpacing(DiscreteGaussianImageFilter self) -> bool"""
        return _SimpleITK.DiscreteGaussianImageFilter_GetUseImageSpacing(self)

    def GetName(self):
        r"""GetName(DiscreteGaussianImageFilter self) -> std::string"""
        return _SimpleITK.DiscreteGaussianImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(DiscreteGaussianImageFilter self) -> std::string"""
        return _SimpleITK.DiscreteGaussianImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(DiscreteGaussianImageFilter self, Image image1) -> Image"""
        return _SimpleITK.DiscreteGaussianImageFilter_Execute(self, image1)

# Register DiscreteGaussianImageFilter in _SimpleITK:
_SimpleITK.DiscreteGaussianImageFilter_swigregister(DiscreteGaussianImageFilter)
class DisplacementFieldJacobianDeterminantFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::DisplacementFieldJacobianDeterminantFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_DisplacementFieldJacobianDeterminantFilter

    def __init__(self):
        r"""__init__(DisplacementFieldJacobianDeterminantFilter self) -> DisplacementFieldJacobianDeterminantFilter"""
        _SimpleITK.DisplacementFieldJacobianDeterminantFilter_swiginit(self, _SimpleITK.new_DisplacementFieldJacobianDeterminantFilter())

    def SetUseImageSpacing(self, UseImageSpacing):
        r"""SetUseImageSpacing(DisplacementFieldJacobianDeterminantFilter self, bool UseImageSpacing)"""
        return _SimpleITK.DisplacementFieldJacobianDeterminantFilter_SetUseImageSpacing(self, UseImageSpacing)

    def UseImageSpacingOn(self):
        r"""UseImageSpacingOn(DisplacementFieldJacobianDeterminantFilter self)"""
        return _SimpleITK.DisplacementFieldJacobianDeterminantFilter_UseImageSpacingOn(self)

    def UseImageSpacingOff(self):
        r"""UseImageSpacingOff(DisplacementFieldJacobianDeterminantFilter self)"""
        return _SimpleITK.DisplacementFieldJacobianDeterminantFilter_UseImageSpacingOff(self)

    def GetUseImageSpacing(self):
        r"""GetUseImageSpacing(DisplacementFieldJacobianDeterminantFilter self) -> bool"""
        return _SimpleITK.DisplacementFieldJacobianDeterminantFilter_GetUseImageSpacing(self)

    def SetDerivativeWeights(self, DerivativeWeights):
        r"""SetDerivativeWeights(DisplacementFieldJacobianDeterminantFilter self, VectorDouble DerivativeWeights)"""
        return _SimpleITK.DisplacementFieldJacobianDeterminantFilter_SetDerivativeWeights(self, DerivativeWeights)

    def GetDerivativeWeights(self):
        r"""GetDerivativeWeights(DisplacementFieldJacobianDeterminantFilter self) -> VectorDouble"""
        return _SimpleITK.DisplacementFieldJacobianDeterminantFilter_GetDerivativeWeights(self)

    def GetName(self):
        r"""GetName(DisplacementFieldJacobianDeterminantFilter self) -> std::string"""
        return _SimpleITK.DisplacementFieldJacobianDeterminantFilter_GetName(self)

    def __str__(self):
        r"""__str__(DisplacementFieldJacobianDeterminantFilter self) -> std::string"""
        return _SimpleITK.DisplacementFieldJacobianDeterminantFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(DisplacementFieldJacobianDeterminantFilter self, Image image1) -> Image"""
        return _SimpleITK.DisplacementFieldJacobianDeterminantFilter_Execute(self, image1)

# Register DisplacementFieldJacobianDeterminantFilter in _SimpleITK:
_SimpleITK.DisplacementFieldJacobianDeterminantFilter_swigregister(DisplacementFieldJacobianDeterminantFilter)

def DisplacementFieldJacobianDeterminant(*args, **kwargs):
    r"""DisplacementFieldJacobianDeterminant(Image image1, bool useImageSpacing=True, VectorDouble derivativeWeights=std::vector< double >()) -> Image"""
    return _SimpleITK.DisplacementFieldJacobianDeterminant(*args, **kwargs)
class DivideFloorImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::DivideFloorImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_DivideFloorImageFilter

    def __init__(self):
        r"""__init__(DivideFloorImageFilter self) -> DivideFloorImageFilter"""
        _SimpleITK.DivideFloorImageFilter_swiginit(self, _SimpleITK.new_DivideFloorImageFilter())

    def GetName(self):
        r"""GetName(DivideFloorImageFilter self) -> std::string"""
        return _SimpleITK.DivideFloorImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(DivideFloorImageFilter self) -> std::string"""
        return _SimpleITK.DivideFloorImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(DivideFloorImageFilter self, Image image1, Image image2) -> Image
        Execute(DivideFloorImageFilter self, Image image1, double constant) -> Image
        Execute(DivideFloorImageFilter self, double constant, Image image2) -> Image
        """
        return _SimpleITK.DivideFloorImageFilter_Execute(self, *args)

# Register DivideFloorImageFilter in _SimpleITK:
_SimpleITK.DivideFloorImageFilter_swigregister(DivideFloorImageFilter)

def DivideFloor(*args):
    r"""
    DivideFloor(Image image1, Image image2) -> Image
    DivideFloor(Image image1, double constant) -> Image
    DivideFloor(double constant, Image image2) -> Image
    """
    return _SimpleITK.DivideFloor(*args)
class DivideImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::DivideImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_DivideImageFilter

    def __init__(self):
        r"""__init__(DivideImageFilter self) -> DivideImageFilter"""
        _SimpleITK.DivideImageFilter_swiginit(self, _SimpleITK.new_DivideImageFilter())

    def GetName(self):
        r"""GetName(DivideImageFilter self) -> std::string"""
        return _SimpleITK.DivideImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(DivideImageFilter self) -> std::string"""
        return _SimpleITK.DivideImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(DivideImageFilter self, Image image1, Image image2) -> Image
        Execute(DivideImageFilter self, Image image1, double constant) -> Image
        Execute(DivideImageFilter self, double constant, Image image2) -> Image
        """
        return _SimpleITK.DivideImageFilter_Execute(self, *args)

# Register DivideImageFilter in _SimpleITK:
_SimpleITK.DivideImageFilter_swigregister(DivideImageFilter)

def Divide(*args):
    r"""
    Divide(Image image1, Image image2) -> Image
    Divide(Image image1, double constant) -> Image
    Divide(double constant, Image image2) -> Image
    """
    return _SimpleITK.Divide(*args)
class DivideRealImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::DivideRealImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_DivideRealImageFilter

    def __init__(self):
        r"""__init__(DivideRealImageFilter self) -> DivideRealImageFilter"""
        _SimpleITK.DivideRealImageFilter_swiginit(self, _SimpleITK.new_DivideRealImageFilter())

    def GetName(self):
        r"""GetName(DivideRealImageFilter self) -> std::string"""
        return _SimpleITK.DivideRealImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(DivideRealImageFilter self) -> std::string"""
        return _SimpleITK.DivideRealImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(DivideRealImageFilter self, Image image1, Image image2) -> Image
        Execute(DivideRealImageFilter self, Image image1, double constant) -> Image
        Execute(DivideRealImageFilter self, double constant, Image image2) -> Image
        """
        return _SimpleITK.DivideRealImageFilter_Execute(self, *args)

# Register DivideRealImageFilter in _SimpleITK:
_SimpleITK.DivideRealImageFilter_swigregister(DivideRealImageFilter)

def DivideReal(*args):
    r"""
    DivideReal(Image image1, Image image2) -> Image
    DivideReal(Image image1, double constant) -> Image
    DivideReal(double constant, Image image2) -> Image
    """
    return _SimpleITK.DivideReal(*args)
class DoubleThresholdImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::DoubleThresholdImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_DoubleThresholdImageFilter

    def __init__(self):
        r"""__init__(DoubleThresholdImageFilter self) -> DoubleThresholdImageFilter"""
        _SimpleITK.DoubleThresholdImageFilter_swiginit(self, _SimpleITK.new_DoubleThresholdImageFilter())

    def SetThreshold1(self, Threshold1):
        r"""SetThreshold1(DoubleThresholdImageFilter self, double Threshold1)"""
        return _SimpleITK.DoubleThresholdImageFilter_SetThreshold1(self, Threshold1)

    def GetThreshold1(self):
        r"""GetThreshold1(DoubleThresholdImageFilter self) -> double"""
        return _SimpleITK.DoubleThresholdImageFilter_GetThreshold1(self)

    def SetThreshold2(self, Threshold2):
        r"""SetThreshold2(DoubleThresholdImageFilter self, double Threshold2)"""
        return _SimpleITK.DoubleThresholdImageFilter_SetThreshold2(self, Threshold2)

    def GetThreshold2(self):
        r"""GetThreshold2(DoubleThresholdImageFilter self) -> double"""
        return _SimpleITK.DoubleThresholdImageFilter_GetThreshold2(self)

    def SetThreshold3(self, Threshold3):
        r"""SetThreshold3(DoubleThresholdImageFilter self, double Threshold3)"""
        return _SimpleITK.DoubleThresholdImageFilter_SetThreshold3(self, Threshold3)

    def GetThreshold3(self):
        r"""GetThreshold3(DoubleThresholdImageFilter self) -> double"""
        return _SimpleITK.DoubleThresholdImageFilter_GetThreshold3(self)

    def SetThreshold4(self, Threshold4):
        r"""SetThreshold4(DoubleThresholdImageFilter self, double Threshold4)"""
        return _SimpleITK.DoubleThresholdImageFilter_SetThreshold4(self, Threshold4)

    def GetThreshold4(self):
        r"""GetThreshold4(DoubleThresholdImageFilter self) -> double"""
        return _SimpleITK.DoubleThresholdImageFilter_GetThreshold4(self)

    def SetInsideValue(self, InsideValue):
        r"""SetInsideValue(DoubleThresholdImageFilter self, uint8_t InsideValue)"""
        return _SimpleITK.DoubleThresholdImageFilter_SetInsideValue(self, InsideValue)

    def GetInsideValue(self):
        r"""GetInsideValue(DoubleThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.DoubleThresholdImageFilter_GetInsideValue(self)

    def SetOutsideValue(self, OutsideValue):
        r"""SetOutsideValue(DoubleThresholdImageFilter self, uint8_t OutsideValue)"""
        return _SimpleITK.DoubleThresholdImageFilter_SetOutsideValue(self, OutsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(DoubleThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.DoubleThresholdImageFilter_GetOutsideValue(self)

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(DoubleThresholdImageFilter self, bool FullyConnected)"""
        return _SimpleITK.DoubleThresholdImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(DoubleThresholdImageFilter self)"""
        return _SimpleITK.DoubleThresholdImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(DoubleThresholdImageFilter self)"""
        return _SimpleITK.DoubleThresholdImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(DoubleThresholdImageFilter self) -> bool"""
        return _SimpleITK.DoubleThresholdImageFilter_GetFullyConnected(self)

    def GetName(self):
        r"""GetName(DoubleThresholdImageFilter self) -> std::string"""
        return _SimpleITK.DoubleThresholdImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(DoubleThresholdImageFilter self) -> std::string"""
        return _SimpleITK.DoubleThresholdImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(DoubleThresholdImageFilter self, Image image1) -> Image"""
        return _SimpleITK.DoubleThresholdImageFilter_Execute(self, image1)

# Register DoubleThresholdImageFilter in _SimpleITK:
_SimpleITK.DoubleThresholdImageFilter_swigregister(DoubleThresholdImageFilter)

def DoubleThreshold(image1, threshold1=0.0, threshold2=1.0, threshold3=254.0, threshold4=255.0, insideValue=1, outsideValue=0, fullyConnected=False):
    r"""DoubleThreshold(Image image1, double threshold1=0.0, double threshold2=1.0, double threshold3=254.0, double threshold4=255.0, uint8_t insideValue=1, uint8_t outsideValue=0, bool fullyConnected=False) -> Image"""
    return _SimpleITK.DoubleThreshold(image1, threshold1, threshold2, threshold3, threshold4, insideValue, outsideValue, fullyConnected)
class EdgePotentialImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::EdgePotentialImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_EdgePotentialImageFilter

    def __init__(self):
        r"""__init__(EdgePotentialImageFilter self) -> EdgePotentialImageFilter"""
        _SimpleITK.EdgePotentialImageFilter_swiginit(self, _SimpleITK.new_EdgePotentialImageFilter())

    def GetName(self):
        r"""GetName(EdgePotentialImageFilter self) -> std::string"""
        return _SimpleITK.EdgePotentialImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(EdgePotentialImageFilter self) -> std::string"""
        return _SimpleITK.EdgePotentialImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(EdgePotentialImageFilter self, Image image1) -> Image"""
        return _SimpleITK.EdgePotentialImageFilter_Execute(self, image1)

# Register EdgePotentialImageFilter in _SimpleITK:
_SimpleITK.EdgePotentialImageFilter_swigregister(EdgePotentialImageFilter)

def EdgePotential(image1):
    r"""EdgePotential(Image image1) -> Image"""
    return _SimpleITK.EdgePotential(image1)
class EqualImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::EqualImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_EqualImageFilter

    def __init__(self):
        r"""__init__(EqualImageFilter self) -> EqualImageFilter"""
        _SimpleITK.EqualImageFilter_swiginit(self, _SimpleITK.new_EqualImageFilter())

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(EqualImageFilter self, uint8_t BackgroundValue)"""
        return _SimpleITK.EqualImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(EqualImageFilter self) -> uint8_t"""
        return _SimpleITK.EqualImageFilter_GetBackgroundValue(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(EqualImageFilter self, uint8_t ForegroundValue)"""
        return _SimpleITK.EqualImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(EqualImageFilter self) -> uint8_t"""
        return _SimpleITK.EqualImageFilter_GetForegroundValue(self)

    def GetName(self):
        r"""GetName(EqualImageFilter self) -> std::string"""
        return _SimpleITK.EqualImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(EqualImageFilter self) -> std::string"""
        return _SimpleITK.EqualImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(EqualImageFilter self, Image image1, Image image2) -> Image
        Execute(EqualImageFilter self, Image image1, double constant) -> Image
        Execute(EqualImageFilter self, double constant, Image image2) -> Image
        Execute(EqualImageFilter self, Image image1, double constant, uint8_t backgroundValue, uint8_t foregroundValue) -> Image
        Execute(EqualImageFilter self, double constant, Image image2, uint8_t backgroundValue, uint8_t foregroundValue) -> Image
        """
        return _SimpleITK.EqualImageFilter_Execute(self, *args)

# Register EqualImageFilter in _SimpleITK:
_SimpleITK.EqualImageFilter_swigregister(EqualImageFilter)

def Equal(*args):
    r"""
    Equal(Image image1, Image image2, uint8_t backgroundValue=0, uint8_t foregroundValue=1) -> Image
    Equal(Image image1, double constant, uint8_t backgroundValue=0, uint8_t foregroundValue=1) -> Image
    Equal(double constant, Image image2, uint8_t backgroundValue=0, uint8_t foregroundValue=1) -> Image
    """
    return _SimpleITK.Equal(*args)
class ErodeObjectMorphologyImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ErodeObjectMorphologyImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ErodeObjectMorphologyImageFilter

    def __init__(self):
        r"""__init__(ErodeObjectMorphologyImageFilter self) -> ErodeObjectMorphologyImageFilter"""
        _SimpleITK.ErodeObjectMorphologyImageFilter_swiginit(self, _SimpleITK.new_ErodeObjectMorphologyImageFilter())

    def SetKernelRadius(self, *args):
        r"""
        SetKernelRadius(ErodeObjectMorphologyImageFilter self, VectorUInt32 KernelRadius)
        SetKernelRadius(ErodeObjectMorphologyImageFilter self, unsigned int value)
        """
        return _SimpleITK.ErodeObjectMorphologyImageFilter_SetKernelRadius(self, *args)

    def GetKernelRadius(self):
        r"""GetKernelRadius(ErodeObjectMorphologyImageFilter self) -> VectorUInt32"""
        return _SimpleITK.ErodeObjectMorphologyImageFilter_GetKernelRadius(self)

    def SetKernelType(self, KernelType):
        r"""SetKernelType(ErodeObjectMorphologyImageFilter self, slicer_itk::simple::KernelEnum KernelType)"""
        return _SimpleITK.ErodeObjectMorphologyImageFilter_SetKernelType(self, KernelType)

    def GetKernelType(self):
        r"""GetKernelType(ErodeObjectMorphologyImageFilter self) -> slicer_itk::simple::KernelEnum"""
        return _SimpleITK.ErodeObjectMorphologyImageFilter_GetKernelType(self)

    def SetObjectValue(self, ObjectValue):
        r"""SetObjectValue(ErodeObjectMorphologyImageFilter self, double ObjectValue)"""
        return _SimpleITK.ErodeObjectMorphologyImageFilter_SetObjectValue(self, ObjectValue)

    def GetObjectValue(self):
        r"""GetObjectValue(ErodeObjectMorphologyImageFilter self) -> double"""
        return _SimpleITK.ErodeObjectMorphologyImageFilter_GetObjectValue(self)

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(ErodeObjectMorphologyImageFilter self, double BackgroundValue)"""
        return _SimpleITK.ErodeObjectMorphologyImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(ErodeObjectMorphologyImageFilter self) -> double"""
        return _SimpleITK.ErodeObjectMorphologyImageFilter_GetBackgroundValue(self)

    def GetName(self):
        r"""GetName(ErodeObjectMorphologyImageFilter self) -> std::string"""
        return _SimpleITK.ErodeObjectMorphologyImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ErodeObjectMorphologyImageFilter self) -> std::string"""
        return _SimpleITK.ErodeObjectMorphologyImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ErodeObjectMorphologyImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ErodeObjectMorphologyImageFilter_Execute(self, image1)

# Register ErodeObjectMorphologyImageFilter in _SimpleITK:
_SimpleITK.ErodeObjectMorphologyImageFilter_swigregister(ErodeObjectMorphologyImageFilter)

def ErodeObjectMorphology(*args, **kwargs):
    r"""ErodeObjectMorphology(Image image1, VectorUInt32 kernelRadius=std::vector< uint32_t >(3, 1), slicer_itk::simple::KernelEnum kernelType=sitkBall, double objectValue=1, double backgroundValue=0) -> Image"""
    return _SimpleITK.ErodeObjectMorphology(*args, **kwargs)
class ExpImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ExpImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ExpImageFilter

    def __init__(self):
        r"""__init__(ExpImageFilter self) -> ExpImageFilter"""
        _SimpleITK.ExpImageFilter_swiginit(self, _SimpleITK.new_ExpImageFilter())

    def GetName(self):
        r"""GetName(ExpImageFilter self) -> std::string"""
        return _SimpleITK.ExpImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ExpImageFilter self) -> std::string"""
        return _SimpleITK.ExpImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ExpImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ExpImageFilter_Execute(self, image1)

# Register ExpImageFilter in _SimpleITK:
_SimpleITK.ExpImageFilter_swigregister(ExpImageFilter)

def Exp(image1):
    r"""Exp(Image image1) -> Image"""
    return _SimpleITK.Exp(image1)
class ExpNegativeImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ExpNegativeImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ExpNegativeImageFilter

    def __init__(self):
        r"""__init__(ExpNegativeImageFilter self) -> ExpNegativeImageFilter"""
        _SimpleITK.ExpNegativeImageFilter_swiginit(self, _SimpleITK.new_ExpNegativeImageFilter())

    def GetName(self):
        r"""GetName(ExpNegativeImageFilter self) -> std::string"""
        return _SimpleITK.ExpNegativeImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ExpNegativeImageFilter self) -> std::string"""
        return _SimpleITK.ExpNegativeImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ExpNegativeImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ExpNegativeImageFilter_Execute(self, image1)

# Register ExpNegativeImageFilter in _SimpleITK:
_SimpleITK.ExpNegativeImageFilter_swigregister(ExpNegativeImageFilter)

def ExpNegative(image1):
    r"""ExpNegative(Image image1) -> Image"""
    return _SimpleITK.ExpNegative(image1)
class ExpandImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ExpandImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ExpandImageFilter

    def __init__(self):
        r"""__init__(ExpandImageFilter self) -> ExpandImageFilter"""
        _SimpleITK.ExpandImageFilter_swiginit(self, _SimpleITK.new_ExpandImageFilter())

    def SetExpandFactor(self, e):
        r"""SetExpandFactor(ExpandImageFilter self, unsigned int e)"""
        return _SimpleITK.ExpandImageFilter_SetExpandFactor(self, e)

    def SetExpandFactors(self, *args):
        r"""
        SetExpandFactors(ExpandImageFilter self, VectorUInt32 ExpandFactors)
        SetExpandFactors(ExpandImageFilter self, unsigned int value)
        """
        return _SimpleITK.ExpandImageFilter_SetExpandFactors(self, *args)

    def GetExpandFactors(self):
        r"""GetExpandFactors(ExpandImageFilter self) -> VectorUInt32"""
        return _SimpleITK.ExpandImageFilter_GetExpandFactors(self)

    def SetInterpolator(self, Interpolator):
        r"""SetInterpolator(ExpandImageFilter self, slicer_itk::simple::InterpolatorEnum Interpolator)"""
        return _SimpleITK.ExpandImageFilter_SetInterpolator(self, Interpolator)

    def GetInterpolator(self):
        r"""GetInterpolator(ExpandImageFilter self) -> slicer_itk::simple::InterpolatorEnum"""
        return _SimpleITK.ExpandImageFilter_GetInterpolator(self)

    def GetName(self):
        r"""GetName(ExpandImageFilter self) -> std::string"""
        return _SimpleITK.ExpandImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ExpandImageFilter self) -> std::string"""
        return _SimpleITK.ExpandImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ExpandImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ExpandImageFilter_Execute(self, image1)

# Register ExpandImageFilter in _SimpleITK:
_SimpleITK.ExpandImageFilter_swigregister(ExpandImageFilter)

def Expand(*args, **kwargs):
    r"""Expand(Image image1, VectorUInt32 expandFactors=std::vector< unsigned int >(3, 1), slicer_itk::simple::InterpolatorEnum interpolator=sitkLinear) -> Image"""
    return _SimpleITK.Expand(*args, **kwargs)
class FFTConvolutionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::FFTConvolutionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_FFTConvolutionImageFilter

    def __init__(self):
        r"""__init__(FFTConvolutionImageFilter self) -> FFTConvolutionImageFilter"""
        _SimpleITK.FFTConvolutionImageFilter_swiginit(self, _SimpleITK.new_FFTConvolutionImageFilter())

    def SetNormalize(self, Normalize):
        r"""SetNormalize(FFTConvolutionImageFilter self, bool Normalize)"""
        return _SimpleITK.FFTConvolutionImageFilter_SetNormalize(self, Normalize)

    def NormalizeOn(self):
        r"""NormalizeOn(FFTConvolutionImageFilter self)"""
        return _SimpleITK.FFTConvolutionImageFilter_NormalizeOn(self)

    def NormalizeOff(self):
        r"""NormalizeOff(FFTConvolutionImageFilter self)"""
        return _SimpleITK.FFTConvolutionImageFilter_NormalizeOff(self)

    def GetNormalize(self):
        r"""GetNormalize(FFTConvolutionImageFilter self) -> bool"""
        return _SimpleITK.FFTConvolutionImageFilter_GetNormalize(self)
    ZERO_PAD = _SimpleITK.FFTConvolutionImageFilter_ZERO_PAD
    
    ZERO_FLUX_NEUMANN_PAD = _SimpleITK.FFTConvolutionImageFilter_ZERO_FLUX_NEUMANN_PAD
    
    PERIODIC_PAD = _SimpleITK.FFTConvolutionImageFilter_PERIODIC_PAD
    

    def SetBoundaryCondition(self, BoundaryCondition):
        r"""SetBoundaryCondition(FFTConvolutionImageFilter self, slicer_itk::simple::FFTConvolutionImageFilter::BoundaryConditionType BoundaryCondition)"""
        return _SimpleITK.FFTConvolutionImageFilter_SetBoundaryCondition(self, BoundaryCondition)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(FFTConvolutionImageFilter self) -> slicer_itk::simple::FFTConvolutionImageFilter::BoundaryConditionType"""
        return _SimpleITK.FFTConvolutionImageFilter_GetBoundaryCondition(self)
    SAME = _SimpleITK.FFTConvolutionImageFilter_SAME
    
    VALID = _SimpleITK.FFTConvolutionImageFilter_VALID
    

    def SetOutputRegionMode(self, OutputRegionMode):
        r"""SetOutputRegionMode(FFTConvolutionImageFilter self, slicer_itk::simple::FFTConvolutionImageFilter::OutputRegionModeType OutputRegionMode)"""
        return _SimpleITK.FFTConvolutionImageFilter_SetOutputRegionMode(self, OutputRegionMode)

    def GetOutputRegionMode(self):
        r"""GetOutputRegionMode(FFTConvolutionImageFilter self) -> slicer_itk::simple::FFTConvolutionImageFilter::OutputRegionModeType"""
        return _SimpleITK.FFTConvolutionImageFilter_GetOutputRegionMode(self)

    def GetName(self):
        r"""GetName(FFTConvolutionImageFilter self) -> std::string"""
        return _SimpleITK.FFTConvolutionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(FFTConvolutionImageFilter self) -> std::string"""
        return _SimpleITK.FFTConvolutionImageFilter___str__(self)

    def Execute(self, image, kernelImage):
        r"""Execute(FFTConvolutionImageFilter self, Image image, Image kernelImage) -> Image"""
        return _SimpleITK.FFTConvolutionImageFilter_Execute(self, image, kernelImage)

# Register FFTConvolutionImageFilter in _SimpleITK:
_SimpleITK.FFTConvolutionImageFilter_swigregister(FFTConvolutionImageFilter)

def FFTConvolution(*args, **kwargs):
    r"""FFTConvolution(Image image, Image kernelImage, bool normalize=False, slicer_itk::simple::FFTConvolutionImageFilter::BoundaryConditionType boundaryCondition=ZERO_FLUX_NEUMANN_PAD, slicer_itk::simple::FFTConvolutionImageFilter::OutputRegionModeType outputRegionMode=SAME) -> Image"""
    return _SimpleITK.FFTConvolution(*args, **kwargs)
class FFTNormalizedCorrelationImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::FFTNormalizedCorrelationImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_FFTNormalizedCorrelationImageFilter

    def __init__(self):
        r"""__init__(FFTNormalizedCorrelationImageFilter self) -> FFTNormalizedCorrelationImageFilter"""
        _SimpleITK.FFTNormalizedCorrelationImageFilter_swiginit(self, _SimpleITK.new_FFTNormalizedCorrelationImageFilter())

    def SetRequiredNumberOfOverlappingPixels(self, RequiredNumberOfOverlappingPixels):
        r"""SetRequiredNumberOfOverlappingPixels(FFTNormalizedCorrelationImageFilter self, uint64_t RequiredNumberOfOverlappingPixels)"""
        return _SimpleITK.FFTNormalizedCorrelationImageFilter_SetRequiredNumberOfOverlappingPixels(self, RequiredNumberOfOverlappingPixels)

    def GetRequiredNumberOfOverlappingPixels(self):
        r"""GetRequiredNumberOfOverlappingPixels(FFTNormalizedCorrelationImageFilter self) -> uint64_t"""
        return _SimpleITK.FFTNormalizedCorrelationImageFilter_GetRequiredNumberOfOverlappingPixels(self)

    def SetRequiredFractionOfOverlappingPixels(self, RequiredFractionOfOverlappingPixels):
        r"""SetRequiredFractionOfOverlappingPixels(FFTNormalizedCorrelationImageFilter self, double RequiredFractionOfOverlappingPixels)"""
        return _SimpleITK.FFTNormalizedCorrelationImageFilter_SetRequiredFractionOfOverlappingPixels(self, RequiredFractionOfOverlappingPixels)

    def GetRequiredFractionOfOverlappingPixels(self):
        r"""GetRequiredFractionOfOverlappingPixels(FFTNormalizedCorrelationImageFilter self) -> double"""
        return _SimpleITK.FFTNormalizedCorrelationImageFilter_GetRequiredFractionOfOverlappingPixels(self)

    def GetName(self):
        r"""GetName(FFTNormalizedCorrelationImageFilter self) -> std::string"""
        return _SimpleITK.FFTNormalizedCorrelationImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(FFTNormalizedCorrelationImageFilter self) -> std::string"""
        return _SimpleITK.FFTNormalizedCorrelationImageFilter___str__(self)

    def Execute(self, fixedImage, movingImage):
        r"""Execute(FFTNormalizedCorrelationImageFilter self, Image fixedImage, Image movingImage) -> Image"""
        return _SimpleITK.FFTNormalizedCorrelationImageFilter_Execute(self, fixedImage, movingImage)

# Register FFTNormalizedCorrelationImageFilter in _SimpleITK:
_SimpleITK.FFTNormalizedCorrelationImageFilter_swigregister(FFTNormalizedCorrelationImageFilter)

def FFTNormalizedCorrelation(fixedImage, movingImage, requiredNumberOfOverlappingPixels=0, requiredFractionOfOverlappingPixels=0.0):
    r"""FFTNormalizedCorrelation(Image fixedImage, Image movingImage, uint64_t requiredNumberOfOverlappingPixels=0, double requiredFractionOfOverlappingPixels=0.0) -> Image"""
    return _SimpleITK.FFTNormalizedCorrelation(fixedImage, movingImage, requiredNumberOfOverlappingPixels, requiredFractionOfOverlappingPixels)
class FFTPadImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::FFTPadImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_FFTPadImageFilter

    def __init__(self):
        r"""__init__(FFTPadImageFilter self) -> FFTPadImageFilter"""
        _SimpleITK.FFTPadImageFilter_swiginit(self, _SimpleITK.new_FFTPadImageFilter())
    ZERO_PAD = _SimpleITK.FFTPadImageFilter_ZERO_PAD
    
    ZERO_FLUX_NEUMANN_PAD = _SimpleITK.FFTPadImageFilter_ZERO_FLUX_NEUMANN_PAD
    
    PERIODIC_PAD = _SimpleITK.FFTPadImageFilter_PERIODIC_PAD
    

    def SetBoundaryCondition(self, BoundaryCondition):
        r"""SetBoundaryCondition(FFTPadImageFilter self, slicer_itk::simple::FFTPadImageFilter::BoundaryConditionType BoundaryCondition)"""
        return _SimpleITK.FFTPadImageFilter_SetBoundaryCondition(self, BoundaryCondition)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(FFTPadImageFilter self) -> slicer_itk::simple::FFTPadImageFilter::BoundaryConditionType"""
        return _SimpleITK.FFTPadImageFilter_GetBoundaryCondition(self)

    def SetSizeGreatestPrimeFactor(self, SizeGreatestPrimeFactor):
        r"""SetSizeGreatestPrimeFactor(FFTPadImageFilter self, int SizeGreatestPrimeFactor)"""
        return _SimpleITK.FFTPadImageFilter_SetSizeGreatestPrimeFactor(self, SizeGreatestPrimeFactor)

    def GetSizeGreatestPrimeFactor(self):
        r"""GetSizeGreatestPrimeFactor(FFTPadImageFilter self) -> int"""
        return _SimpleITK.FFTPadImageFilter_GetSizeGreatestPrimeFactor(self)

    def GetName(self):
        r"""GetName(FFTPadImageFilter self) -> std::string"""
        return _SimpleITK.FFTPadImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(FFTPadImageFilter self) -> std::string"""
        return _SimpleITK.FFTPadImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(FFTPadImageFilter self, Image image1) -> Image"""
        return _SimpleITK.FFTPadImageFilter_Execute(self, image1)

    @staticmethod
    def DefaultSizeGreatestPrimeFactor():
        r"""DefaultSizeGreatestPrimeFactor() -> int"""
        return _SimpleITK.FFTPadImageFilter_DefaultSizeGreatestPrimeFactor()

# Register FFTPadImageFilter in _SimpleITK:
_SimpleITK.FFTPadImageFilter_swigregister(FFTPadImageFilter)

def FFTPadImageFilter_DefaultSizeGreatestPrimeFactor():
    r"""FFTPadImageFilter_DefaultSizeGreatestPrimeFactor() -> int"""
    return _SimpleITK.FFTPadImageFilter_DefaultSizeGreatestPrimeFactor()


def FFTPad(*args, **kwargs):
    r"""FFTPad(Image image1, slicer_itk::simple::FFTPadImageFilter::BoundaryConditionType boundaryCondition=ZERO_FLUX_NEUMANN_PAD, int sizeGreatestPrimeFactor=slicer_itk::simple::FFTPadImageFilter::DefaultSizeGreatestPrimeFactor()) -> Image"""
    return _SimpleITK.FFTPad(*args, **kwargs)
class FFTShiftImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::FFTShiftImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_FFTShiftImageFilter

    def __init__(self):
        r"""__init__(FFTShiftImageFilter self) -> FFTShiftImageFilter"""
        _SimpleITK.FFTShiftImageFilter_swiginit(self, _SimpleITK.new_FFTShiftImageFilter())

    def SetInverse(self, Inverse):
        r"""SetInverse(FFTShiftImageFilter self, bool Inverse)"""
        return _SimpleITK.FFTShiftImageFilter_SetInverse(self, Inverse)

    def InverseOn(self):
        r"""InverseOn(FFTShiftImageFilter self)"""
        return _SimpleITK.FFTShiftImageFilter_InverseOn(self)

    def InverseOff(self):
        r"""InverseOff(FFTShiftImageFilter self)"""
        return _SimpleITK.FFTShiftImageFilter_InverseOff(self)

    def GetInverse(self):
        r"""GetInverse(FFTShiftImageFilter self) -> bool"""
        return _SimpleITK.FFTShiftImageFilter_GetInverse(self)

    def GetName(self):
        r"""GetName(FFTShiftImageFilter self) -> std::string"""
        return _SimpleITK.FFTShiftImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(FFTShiftImageFilter self) -> std::string"""
        return _SimpleITK.FFTShiftImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(FFTShiftImageFilter self, Image image1) -> Image"""
        return _SimpleITK.FFTShiftImageFilter_Execute(self, image1)

# Register FFTShiftImageFilter in _SimpleITK:
_SimpleITK.FFTShiftImageFilter_swigregister(FFTShiftImageFilter)

def FFTShift(image1, inverse=False):
    r"""FFTShift(Image image1, bool inverse=False) -> Image"""
    return _SimpleITK.FFTShift(image1, inverse)
class FastApproximateRankImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::FastApproximateRankImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_FastApproximateRankImageFilter

    def __init__(self):
        r"""__init__(FastApproximateRankImageFilter self) -> FastApproximateRankImageFilter"""
        _SimpleITK.FastApproximateRankImageFilter_swiginit(self, _SimpleITK.new_FastApproximateRankImageFilter())

    def SetRank(self, Rank):
        r"""SetRank(FastApproximateRankImageFilter self, double Rank)"""
        return _SimpleITK.FastApproximateRankImageFilter_SetRank(self, Rank)

    def GetRank(self):
        r"""GetRank(FastApproximateRankImageFilter self) -> double"""
        return _SimpleITK.FastApproximateRankImageFilter_GetRank(self)

    def SetRadius(self, *args):
        r"""
        SetRadius(FastApproximateRankImageFilter self, VectorUInt32 Radius)
        SetRadius(FastApproximateRankImageFilter self, unsigned int value)
        """
        return _SimpleITK.FastApproximateRankImageFilter_SetRadius(self, *args)

    def GetRadius(self):
        r"""GetRadius(FastApproximateRankImageFilter self) -> VectorUInt32"""
        return _SimpleITK.FastApproximateRankImageFilter_GetRadius(self)

    def GetName(self):
        r"""GetName(FastApproximateRankImageFilter self) -> std::string"""
        return _SimpleITK.FastApproximateRankImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(FastApproximateRankImageFilter self) -> std::string"""
        return _SimpleITK.FastApproximateRankImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(FastApproximateRankImageFilter self, Image image1) -> Image"""
        return _SimpleITK.FastApproximateRankImageFilter_Execute(self, image1)

# Register FastApproximateRankImageFilter in _SimpleITK:
_SimpleITK.FastApproximateRankImageFilter_swigregister(FastApproximateRankImageFilter)

def FastApproximateRank(*args, **kwargs):
    r"""FastApproximateRank(Image image1, double rank=0.5, VectorUInt32 radius=std::vector< unsigned int >(3, 1)) -> Image"""
    return _SimpleITK.FastApproximateRank(*args, **kwargs)
class FastMarchingBaseImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::FastMarchingBaseImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_FastMarchingBaseImageFilter

    def __init__(self):
        r"""__init__(FastMarchingBaseImageFilter self) -> FastMarchingBaseImageFilter"""
        _SimpleITK.FastMarchingBaseImageFilter_swiginit(self, _SimpleITK.new_FastMarchingBaseImageFilter())

    def SetTrialPoints(self, TrialPoints):
        r"""SetTrialPoints(FastMarchingBaseImageFilter self, VectorUIntList TrialPoints)"""
        return _SimpleITK.FastMarchingBaseImageFilter_SetTrialPoints(self, TrialPoints)

    def GetTrialPoints(self):
        r"""GetTrialPoints(FastMarchingBaseImageFilter self) -> VectorUIntList"""
        return _SimpleITK.FastMarchingBaseImageFilter_GetTrialPoints(self)

    def AddTrialPoint(self, point):
        r"""AddTrialPoint(FastMarchingBaseImageFilter self, VectorUInt32 point)"""
        return _SimpleITK.FastMarchingBaseImageFilter_AddTrialPoint(self, point)

    def ClearTrialPoints(self):
        r"""ClearTrialPoints(FastMarchingBaseImageFilter self)"""
        return _SimpleITK.FastMarchingBaseImageFilter_ClearTrialPoints(self)

    def SetNormalizationFactor(self, NormalizationFactor):
        r"""SetNormalizationFactor(FastMarchingBaseImageFilter self, double NormalizationFactor)"""
        return _SimpleITK.FastMarchingBaseImageFilter_SetNormalizationFactor(self, NormalizationFactor)

    def GetNormalizationFactor(self):
        r"""GetNormalizationFactor(FastMarchingBaseImageFilter self) -> double"""
        return _SimpleITK.FastMarchingBaseImageFilter_GetNormalizationFactor(self)

    def SetStoppingValue(self, StoppingValue):
        r"""SetStoppingValue(FastMarchingBaseImageFilter self, double StoppingValue)"""
        return _SimpleITK.FastMarchingBaseImageFilter_SetStoppingValue(self, StoppingValue)

    def GetStoppingValue(self):
        r"""GetStoppingValue(FastMarchingBaseImageFilter self) -> double"""
        return _SimpleITK.FastMarchingBaseImageFilter_GetStoppingValue(self)
    Nothing = _SimpleITK.FastMarchingBaseImageFilter_Nothing
    
    NoHandles = _SimpleITK.FastMarchingBaseImageFilter_NoHandles
    
    Strict = _SimpleITK.FastMarchingBaseImageFilter_Strict
    

    def SetTopologyCheck(self, TopologyCheck):
        r"""SetTopologyCheck(FastMarchingBaseImageFilter self, slicer_itk::simple::FastMarchingBaseImageFilter::TopologyCheckType TopologyCheck)"""
        return _SimpleITK.FastMarchingBaseImageFilter_SetTopologyCheck(self, TopologyCheck)

    def GetTopologyCheck(self):
        r"""GetTopologyCheck(FastMarchingBaseImageFilter self) -> slicer_itk::simple::FastMarchingBaseImageFilter::TopologyCheckType"""
        return _SimpleITK.FastMarchingBaseImageFilter_GetTopologyCheck(self)

    def SetInitialTrialValues(self, InitialTrialValues):
        r"""SetInitialTrialValues(FastMarchingBaseImageFilter self, VectorDouble InitialTrialValues)"""
        return _SimpleITK.FastMarchingBaseImageFilter_SetInitialTrialValues(self, InitialTrialValues)

    def GetInitialTrialValues(self):
        r"""GetInitialTrialValues(FastMarchingBaseImageFilter self) -> VectorDouble"""
        return _SimpleITK.FastMarchingBaseImageFilter_GetInitialTrialValues(self)

    def GetName(self):
        r"""GetName(FastMarchingBaseImageFilter self) -> std::string"""
        return _SimpleITK.FastMarchingBaseImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(FastMarchingBaseImageFilter self) -> std::string"""
        return _SimpleITK.FastMarchingBaseImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(FastMarchingBaseImageFilter self, Image image1) -> Image"""
        return _SimpleITK.FastMarchingBaseImageFilter_Execute(self, image1)

# Register FastMarchingBaseImageFilter in _SimpleITK:
_SimpleITK.FastMarchingBaseImageFilter_swigregister(FastMarchingBaseImageFilter)

def FastMarchingBase(*args, **kwargs):
    r"""FastMarchingBase(Image image1, VectorUIntList trialPoints=std::vector< std::vector< unsigned int > >(), double normalizationFactor=1.0, double stoppingValue=std::numeric_limits< float >::max()/2.0, slicer_itk::simple::FastMarchingBaseImageFilter::TopologyCheckType topologyCheck=Nothing, VectorDouble initialTrialValues=std::vector< double >()) -> Image"""
    return _SimpleITK.FastMarchingBase(*args, **kwargs)
class FastMarchingImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::FastMarchingImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_FastMarchingImageFilter

    def __init__(self):
        r"""__init__(FastMarchingImageFilter self) -> FastMarchingImageFilter"""
        _SimpleITK.FastMarchingImageFilter_swiginit(self, _SimpleITK.new_FastMarchingImageFilter())

    def SetTrialPoints(self, TrialPoints):
        r"""SetTrialPoints(FastMarchingImageFilter self, VectorUIntList TrialPoints)"""
        return _SimpleITK.FastMarchingImageFilter_SetTrialPoints(self, TrialPoints)

    def GetTrialPoints(self):
        r"""GetTrialPoints(FastMarchingImageFilter self) -> VectorUIntList"""
        return _SimpleITK.FastMarchingImageFilter_GetTrialPoints(self)

    def AddTrialPoint(self, point):
        r"""AddTrialPoint(FastMarchingImageFilter self, VectorUInt32 point)"""
        return _SimpleITK.FastMarchingImageFilter_AddTrialPoint(self, point)

    def ClearTrialPoints(self):
        r"""ClearTrialPoints(FastMarchingImageFilter self)"""
        return _SimpleITK.FastMarchingImageFilter_ClearTrialPoints(self)

    def SetNormalizationFactor(self, NormalizationFactor):
        r"""SetNormalizationFactor(FastMarchingImageFilter self, double NormalizationFactor)"""
        return _SimpleITK.FastMarchingImageFilter_SetNormalizationFactor(self, NormalizationFactor)

    def GetNormalizationFactor(self):
        r"""GetNormalizationFactor(FastMarchingImageFilter self) -> double"""
        return _SimpleITK.FastMarchingImageFilter_GetNormalizationFactor(self)

    def SetStoppingValue(self, StoppingValue):
        r"""SetStoppingValue(FastMarchingImageFilter self, double StoppingValue)"""
        return _SimpleITK.FastMarchingImageFilter_SetStoppingValue(self, StoppingValue)

    def GetStoppingValue(self):
        r"""GetStoppingValue(FastMarchingImageFilter self) -> double"""
        return _SimpleITK.FastMarchingImageFilter_GetStoppingValue(self)

    def SetInitialTrialValues(self, InitialTrialValues):
        r"""SetInitialTrialValues(FastMarchingImageFilter self, VectorDouble InitialTrialValues)"""
        return _SimpleITK.FastMarchingImageFilter_SetInitialTrialValues(self, InitialTrialValues)

    def GetInitialTrialValues(self):
        r"""GetInitialTrialValues(FastMarchingImageFilter self) -> VectorDouble"""
        return _SimpleITK.FastMarchingImageFilter_GetInitialTrialValues(self)

    def GetName(self):
        r"""GetName(FastMarchingImageFilter self) -> std::string"""
        return _SimpleITK.FastMarchingImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(FastMarchingImageFilter self) -> std::string"""
        return _SimpleITK.FastMarchingImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(FastMarchingImageFilter self, Image image1) -> Image"""
        return _SimpleITK.FastMarchingImageFilter_Execute(self, image1)

# Register FastMarchingImageFilter in _SimpleITK:
_SimpleITK.FastMarchingImageFilter_swigregister(FastMarchingImageFilter)

def FastMarching(*args, **kwargs):
    r"""FastMarching(Image image1, VectorUIntList trialPoints=std::vector< std::vector< unsigned int > >(), double normalizationFactor=1.0, double stoppingValue=std::numeric_limits< double >::max()/2.0, VectorDouble initialTrialValues=std::vector< double >()) -> Image"""
    return _SimpleITK.FastMarching(*args, **kwargs)
class FastMarchingUpwindGradientImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::FastMarchingUpwindGradientImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_FastMarchingUpwindGradientImageFilter

    def __init__(self):
        r"""__init__(FastMarchingUpwindGradientImageFilter self) -> FastMarchingUpwindGradientImageFilter"""
        _SimpleITK.FastMarchingUpwindGradientImageFilter_swiginit(self, _SimpleITK.new_FastMarchingUpwindGradientImageFilter())

    def SetTrialPoints(self, TrialPoints):
        r"""SetTrialPoints(FastMarchingUpwindGradientImageFilter self, VectorUIntList TrialPoints)"""
        return _SimpleITK.FastMarchingUpwindGradientImageFilter_SetTrialPoints(self, TrialPoints)

    def GetTrialPoints(self):
        r"""GetTrialPoints(FastMarchingUpwindGradientImageFilter self) -> VectorUIntList"""
        return _SimpleITK.FastMarchingUpwindGradientImageFilter_GetTrialPoints(self)

    def AddTrialPoint(self, point):
        r"""AddTrialPoint(FastMarchingUpwindGradientImageFilter self, VectorUInt32 point)"""
        return _SimpleITK.FastMarchingUpwindGradientImageFilter_AddTrialPoint(self, point)

    def ClearTrialPoints(self):
        r"""ClearTrialPoints(FastMarchingUpwindGradientImageFilter self)"""
        return _SimpleITK.FastMarchingUpwindGradientImageFilter_ClearTrialPoints(self)

    def SetNumberOfTargets(self, NumberOfTargets):
        r"""SetNumberOfTargets(FastMarchingUpwindGradientImageFilter self, unsigned int NumberOfTargets)"""
        return _SimpleITK.FastMarchingUpwindGradientImageFilter_SetNumberOfTargets(self, NumberOfTargets)

    def GetNumberOfTargets(self):
        r"""GetNumberOfTargets(FastMarchingUpwindGradientImageFilter self) -> unsigned int"""
        return _SimpleITK.FastMarchingUpwindGradientImageFilter_GetNumberOfTargets(self)

    def SetTargetPoints(self, TargetPoints):
        r"""SetTargetPoints(FastMarchingUpwindGradientImageFilter self, VectorUIntList TargetPoints)"""
        return _SimpleITK.FastMarchingUpwindGradientImageFilter_SetTargetPoints(self, TargetPoints)

    def GetTargetPoints(self):
        r"""GetTargetPoints(FastMarchingUpwindGradientImageFilter self) -> VectorUIntList"""
        return _SimpleITK.FastMarchingUpwindGradientImageFilter_GetTargetPoints(self)

    def AddTargetPoint(self, point):
        r"""AddTargetPoint(FastMarchingUpwindGradientImageFilter self, VectorUInt32 point)"""
        return _SimpleITK.FastMarchingUpwindGradientImageFilter_AddTargetPoint(self, point)

    def ClearTargetPoints(self):
        r"""ClearTargetPoints(FastMarchingUpwindGradientImageFilter self)"""
        return _SimpleITK.FastMarchingUpwindGradientImageFilter_ClearTargetPoints(self)

    def SetTargetOffset(self, TargetOffset):
        r"""SetTargetOffset(FastMarchingUpwindGradientImageFilter self, double TargetOffset)"""
        return _SimpleITK.FastMarchingUpwindGradientImageFilter_SetTargetOffset(self, TargetOffset)

    def GetTargetOffset(self):
        r"""GetTargetOffset(FastMarchingUpwindGradientImageFilter self) -> double"""
        return _SimpleITK.FastMarchingUpwindGradientImageFilter_GetTargetOffset(self)

    def SetNormalizationFactor(self, NormalizationFactor):
        r"""SetNormalizationFactor(FastMarchingUpwindGradientImageFilter self, double NormalizationFactor)"""
        return _SimpleITK.FastMarchingUpwindGradientImageFilter_SetNormalizationFactor(self, NormalizationFactor)

    def GetNormalizationFactor(self):
        r"""GetNormalizationFactor(FastMarchingUpwindGradientImageFilter self) -> double"""
        return _SimpleITK.FastMarchingUpwindGradientImageFilter_GetNormalizationFactor(self)

    def SetInitialTrialValues(self, InitialTrialValues):
        r"""SetInitialTrialValues(FastMarchingUpwindGradientImageFilter self, VectorDouble InitialTrialValues)"""
        return _SimpleITK.FastMarchingUpwindGradientImageFilter_SetInitialTrialValues(self, InitialTrialValues)

    def GetInitialTrialValues(self):
        r"""GetInitialTrialValues(FastMarchingUpwindGradientImageFilter self) -> VectorDouble"""
        return _SimpleITK.FastMarchingUpwindGradientImageFilter_GetInitialTrialValues(self)

    def GetGradientImage(self):
        r"""GetGradientImage(FastMarchingUpwindGradientImageFilter self) -> Image"""
        return _SimpleITK.FastMarchingUpwindGradientImageFilter_GetGradientImage(self)

    def GetTargetValue(self):
        r"""GetTargetValue(FastMarchingUpwindGradientImageFilter self) -> double"""
        return _SimpleITK.FastMarchingUpwindGradientImageFilter_GetTargetValue(self)

    def GetName(self):
        r"""GetName(FastMarchingUpwindGradientImageFilter self) -> std::string"""
        return _SimpleITK.FastMarchingUpwindGradientImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(FastMarchingUpwindGradientImageFilter self) -> std::string"""
        return _SimpleITK.FastMarchingUpwindGradientImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(FastMarchingUpwindGradientImageFilter self, Image image1) -> Image"""
        return _SimpleITK.FastMarchingUpwindGradientImageFilter_Execute(self, image1)

# Register FastMarchingUpwindGradientImageFilter in _SimpleITK:
_SimpleITK.FastMarchingUpwindGradientImageFilter_swigregister(FastMarchingUpwindGradientImageFilter)

def FastMarchingUpwindGradient(*args, **kwargs):
    r"""FastMarchingUpwindGradient(Image image1, VectorUIntList trialPoints=std::vector< std::vector< unsigned int > >(), unsigned int numberOfTargets=0, VectorUIntList targetPoints=std::vector< std::vector< unsigned int > >(), double targetOffset=1.0, double normalizationFactor=1.0, VectorDouble initialTrialValues=std::vector< double >()) -> Image"""
    return _SimpleITK.FastMarchingUpwindGradient(*args, **kwargs)
class FastSymmetricForcesDemonsRegistrationFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::FastSymmetricForcesDemonsRegistrationFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_FastSymmetricForcesDemonsRegistrationFilter

    def __init__(self):
        r"""__init__(FastSymmetricForcesDemonsRegistrationFilter self) -> FastSymmetricForcesDemonsRegistrationFilter"""
        _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_swiginit(self, _SimpleITK.new_FastSymmetricForcesDemonsRegistrationFilter())

    def SetStandardDeviations(self, *args):
        r"""
        SetStandardDeviations(FastSymmetricForcesDemonsRegistrationFilter self, VectorDouble StandardDeviations)
        SetStandardDeviations(FastSymmetricForcesDemonsRegistrationFilter self, double value)
        """
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_SetStandardDeviations(self, *args)

    def GetStandardDeviations(self):
        r"""GetStandardDeviations(FastSymmetricForcesDemonsRegistrationFilter self) -> VectorDouble"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_GetStandardDeviations(self)

    def SetNumberOfIterations(self, NumberOfIterations):
        r"""SetNumberOfIterations(FastSymmetricForcesDemonsRegistrationFilter self, uint32_t NumberOfIterations)"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_SetNumberOfIterations(self, NumberOfIterations)

    def GetNumberOfIterations(self):
        r"""GetNumberOfIterations(FastSymmetricForcesDemonsRegistrationFilter self) -> uint32_t"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_GetNumberOfIterations(self)

    def SetMaximumRMSError(self, MaximumRMSError):
        r"""SetMaximumRMSError(FastSymmetricForcesDemonsRegistrationFilter self, double MaximumRMSError)"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_SetMaximumRMSError(self, MaximumRMSError)

    def GetMaximumRMSError(self):
        r"""GetMaximumRMSError(FastSymmetricForcesDemonsRegistrationFilter self) -> double"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_GetMaximumRMSError(self)
    Symmetric = _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_Symmetric
    
    Fixed = _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_Fixed
    
    WarpedMoving = _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_WarpedMoving
    
    MappedMoving = _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_MappedMoving
    

    def SetUseGradientType(self, UseGradientType):
        r"""SetUseGradientType(FastSymmetricForcesDemonsRegistrationFilter self, slicer_itk::simple::FastSymmetricForcesDemonsRegistrationFilter::UseGradientTypeType UseGradientType)"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_SetUseGradientType(self, UseGradientType)

    def GetUseGradientType(self):
        r"""GetUseGradientType(FastSymmetricForcesDemonsRegistrationFilter self) -> slicer_itk::simple::FastSymmetricForcesDemonsRegistrationFilter::UseGradientTypeType"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_GetUseGradientType(self)

    def SetMaximumUpdateStepLength(self, MaximumUpdateStepLength):
        r"""SetMaximumUpdateStepLength(FastSymmetricForcesDemonsRegistrationFilter self, double MaximumUpdateStepLength)"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_SetMaximumUpdateStepLength(self, MaximumUpdateStepLength)

    def GetMaximumUpdateStepLength(self):
        r"""GetMaximumUpdateStepLength(FastSymmetricForcesDemonsRegistrationFilter self) -> double"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_GetMaximumUpdateStepLength(self)

    def SetSmoothDisplacementField(self, SmoothDisplacementField):
        r"""SetSmoothDisplacementField(FastSymmetricForcesDemonsRegistrationFilter self, bool SmoothDisplacementField)"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_SetSmoothDisplacementField(self, SmoothDisplacementField)

    def SmoothDisplacementFieldOn(self):
        r"""SmoothDisplacementFieldOn(FastSymmetricForcesDemonsRegistrationFilter self)"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_SmoothDisplacementFieldOn(self)

    def SmoothDisplacementFieldOff(self):
        r"""SmoothDisplacementFieldOff(FastSymmetricForcesDemonsRegistrationFilter self)"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_SmoothDisplacementFieldOff(self)

    def GetSmoothDisplacementField(self):
        r"""GetSmoothDisplacementField(FastSymmetricForcesDemonsRegistrationFilter self) -> bool"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_GetSmoothDisplacementField(self)

    def SetSmoothUpdateField(self, SmoothUpdateField):
        r"""SetSmoothUpdateField(FastSymmetricForcesDemonsRegistrationFilter self, bool SmoothUpdateField)"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_SetSmoothUpdateField(self, SmoothUpdateField)

    def SmoothUpdateFieldOn(self):
        r"""SmoothUpdateFieldOn(FastSymmetricForcesDemonsRegistrationFilter self)"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_SmoothUpdateFieldOn(self)

    def SmoothUpdateFieldOff(self):
        r"""SmoothUpdateFieldOff(FastSymmetricForcesDemonsRegistrationFilter self)"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_SmoothUpdateFieldOff(self)

    def GetSmoothUpdateField(self):
        r"""GetSmoothUpdateField(FastSymmetricForcesDemonsRegistrationFilter self) -> bool"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_GetSmoothUpdateField(self)

    def SetUpdateFieldStandardDeviations(self, *args):
        r"""
        SetUpdateFieldStandardDeviations(FastSymmetricForcesDemonsRegistrationFilter self, VectorDouble UpdateFieldStandardDeviations)
        SetUpdateFieldStandardDeviations(FastSymmetricForcesDemonsRegistrationFilter self, double value)
        """
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_SetUpdateFieldStandardDeviations(self, *args)

    def GetUpdateFieldStandardDeviations(self):
        r"""GetUpdateFieldStandardDeviations(FastSymmetricForcesDemonsRegistrationFilter self) -> VectorDouble"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_GetUpdateFieldStandardDeviations(self)

    def SetMaximumKernelWidth(self, MaximumKernelWidth):
        r"""SetMaximumKernelWidth(FastSymmetricForcesDemonsRegistrationFilter self, unsigned int MaximumKernelWidth)"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_SetMaximumKernelWidth(self, MaximumKernelWidth)

    def GetMaximumKernelWidth(self):
        r"""GetMaximumKernelWidth(FastSymmetricForcesDemonsRegistrationFilter self) -> unsigned int"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_GetMaximumKernelWidth(self)

    def SetMaximumError(self, MaximumError):
        r"""SetMaximumError(FastSymmetricForcesDemonsRegistrationFilter self, double MaximumError)"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_SetMaximumError(self, MaximumError)

    def GetMaximumError(self):
        r"""GetMaximumError(FastSymmetricForcesDemonsRegistrationFilter self) -> double"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_GetMaximumError(self)

    def SetIntensityDifferenceThreshold(self, IntensityDifferenceThreshold):
        r"""SetIntensityDifferenceThreshold(FastSymmetricForcesDemonsRegistrationFilter self, double IntensityDifferenceThreshold)"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_SetIntensityDifferenceThreshold(self, IntensityDifferenceThreshold)

    def GetIntensityDifferenceThreshold(self):
        r"""GetIntensityDifferenceThreshold(FastSymmetricForcesDemonsRegistrationFilter self) -> double"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_GetIntensityDifferenceThreshold(self)

    def SetUseImageSpacing(self, UseImageSpacing):
        r"""SetUseImageSpacing(FastSymmetricForcesDemonsRegistrationFilter self, bool UseImageSpacing)"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_SetUseImageSpacing(self, UseImageSpacing)

    def UseImageSpacingOn(self):
        r"""UseImageSpacingOn(FastSymmetricForcesDemonsRegistrationFilter self)"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_UseImageSpacingOn(self)

    def UseImageSpacingOff(self):
        r"""UseImageSpacingOff(FastSymmetricForcesDemonsRegistrationFilter self)"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_UseImageSpacingOff(self)

    def GetUseImageSpacing(self):
        r"""GetUseImageSpacing(FastSymmetricForcesDemonsRegistrationFilter self) -> bool"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_GetUseImageSpacing(self)

    def GetElapsedIterations(self):
        r"""GetElapsedIterations(FastSymmetricForcesDemonsRegistrationFilter self) -> uint32_t"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_GetElapsedIterations(self)

    def GetRMSChange(self):
        r"""GetRMSChange(FastSymmetricForcesDemonsRegistrationFilter self) -> double"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_GetRMSChange(self)

    def GetMetric(self):
        r"""GetMetric(FastSymmetricForcesDemonsRegistrationFilter self) -> double"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_GetMetric(self)

    def StopRegistration(self):
        r"""StopRegistration(FastSymmetricForcesDemonsRegistrationFilter self)"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_StopRegistration(self)

    def GetName(self):
        r"""GetName(FastSymmetricForcesDemonsRegistrationFilter self) -> std::string"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_GetName(self)

    def __str__(self):
        r"""__str__(FastSymmetricForcesDemonsRegistrationFilter self) -> std::string"""
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(FastSymmetricForcesDemonsRegistrationFilter self, Image fixedImage, Image movingImage, Image initialDisplacementField) -> Image
        Execute(FastSymmetricForcesDemonsRegistrationFilter self, Image fixedImage, Image movingImage) -> Image
        """
        return _SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_Execute(self, *args)

# Register FastSymmetricForcesDemonsRegistrationFilter in _SimpleITK:
_SimpleITK.FastSymmetricForcesDemonsRegistrationFilter_swigregister(FastSymmetricForcesDemonsRegistrationFilter)
class FlipImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::FlipImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_FlipImageFilter

    def __init__(self):
        r"""__init__(FlipImageFilter self) -> FlipImageFilter"""
        _SimpleITK.FlipImageFilter_swiginit(self, _SimpleITK.new_FlipImageFilter())

    def SetFlipAxes(self, FlipAxes):
        r"""SetFlipAxes(FlipImageFilter self, VectorBool FlipAxes)"""
        return _SimpleITK.FlipImageFilter_SetFlipAxes(self, FlipAxes)

    def GetFlipAxes(self):
        r"""GetFlipAxes(FlipImageFilter self) -> VectorBool"""
        return _SimpleITK.FlipImageFilter_GetFlipAxes(self)

    def SetFlipAboutOrigin(self, FlipAboutOrigin):
        r"""SetFlipAboutOrigin(FlipImageFilter self, bool FlipAboutOrigin)"""
        return _SimpleITK.FlipImageFilter_SetFlipAboutOrigin(self, FlipAboutOrigin)

    def FlipAboutOriginOn(self):
        r"""FlipAboutOriginOn(FlipImageFilter self)"""
        return _SimpleITK.FlipImageFilter_FlipAboutOriginOn(self)

    def FlipAboutOriginOff(self):
        r"""FlipAboutOriginOff(FlipImageFilter self)"""
        return _SimpleITK.FlipImageFilter_FlipAboutOriginOff(self)

    def GetFlipAboutOrigin(self):
        r"""GetFlipAboutOrigin(FlipImageFilter self) -> bool"""
        return _SimpleITK.FlipImageFilter_GetFlipAboutOrigin(self)

    def GetName(self):
        r"""GetName(FlipImageFilter self) -> std::string"""
        return _SimpleITK.FlipImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(FlipImageFilter self) -> std::string"""
        return _SimpleITK.FlipImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(FlipImageFilter self, Image image1) -> Image"""
        return _SimpleITK.FlipImageFilter_Execute(self, image1)

# Register FlipImageFilter in _SimpleITK:
_SimpleITK.FlipImageFilter_swigregister(FlipImageFilter)

def Flip(*args, **kwargs):
    r"""Flip(Image image1, VectorBool flipAxes=std::vector< bool >(3, false), bool flipAboutOrigin=False) -> Image"""
    return _SimpleITK.Flip(*args, **kwargs)
class ForwardFFTImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ForwardFFTImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ForwardFFTImageFilter

    def __init__(self):
        r"""__init__(ForwardFFTImageFilter self) -> ForwardFFTImageFilter"""
        _SimpleITK.ForwardFFTImageFilter_swiginit(self, _SimpleITK.new_ForwardFFTImageFilter())

    def GetName(self):
        r"""GetName(ForwardFFTImageFilter self) -> std::string"""
        return _SimpleITK.ForwardFFTImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ForwardFFTImageFilter self) -> std::string"""
        return _SimpleITK.ForwardFFTImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ForwardFFTImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ForwardFFTImageFilter_Execute(self, image1)

# Register ForwardFFTImageFilter in _SimpleITK:
_SimpleITK.ForwardFFTImageFilter_swigregister(ForwardFFTImageFilter)

def ForwardFFT(image1):
    r"""ForwardFFT(Image image1) -> Image"""
    return _SimpleITK.ForwardFFT(image1)
class GaborImageSource(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::GaborImageSource class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_GaborImageSource

    def __init__(self):
        r"""__init__(GaborImageSource self) -> GaborImageSource"""
        _SimpleITK.GaborImageSource_swiginit(self, _SimpleITK.new_GaborImageSource())

    def SetOutputPixelType(self, OutputPixelType):
        r"""SetOutputPixelType(GaborImageSource self, slicer_itk::simple::PixelIDValueEnum OutputPixelType)"""
        return _SimpleITK.GaborImageSource_SetOutputPixelType(self, OutputPixelType)

    def GetOutputPixelType(self):
        r"""GetOutputPixelType(GaborImageSource self) -> slicer_itk::simple::PixelIDValueEnum"""
        return _SimpleITK.GaborImageSource_GetOutputPixelType(self)

    def SetSize(self, Size):
        r"""SetSize(GaborImageSource self, VectorUInt32 Size)"""
        return _SimpleITK.GaborImageSource_SetSize(self, Size)

    def GetSize(self):
        r"""GetSize(GaborImageSource self) -> VectorUInt32"""
        return _SimpleITK.GaborImageSource_GetSize(self)

    def SetSigma(self, *args):
        r"""
        SetSigma(GaborImageSource self, VectorDouble Sigma)
        SetSigma(GaborImageSource self, double value)
        """
        return _SimpleITK.GaborImageSource_SetSigma(self, *args)

    def GetSigma(self):
        r"""GetSigma(GaborImageSource self) -> VectorDouble"""
        return _SimpleITK.GaborImageSource_GetSigma(self)

    def SetMean(self, *args):
        r"""
        SetMean(GaborImageSource self, VectorDouble Mean)
        SetMean(GaborImageSource self, double value)
        """
        return _SimpleITK.GaborImageSource_SetMean(self, *args)

    def GetMean(self):
        r"""GetMean(GaborImageSource self) -> VectorDouble"""
        return _SimpleITK.GaborImageSource_GetMean(self)

    def SetFrequency(self, Frequency):
        r"""SetFrequency(GaborImageSource self, double Frequency)"""
        return _SimpleITK.GaborImageSource_SetFrequency(self, Frequency)

    def GetFrequency(self):
        r"""GetFrequency(GaborImageSource self) -> double"""
        return _SimpleITK.GaborImageSource_GetFrequency(self)

    def SetOrigin(self, Origin):
        r"""SetOrigin(GaborImageSource self, VectorDouble Origin)"""
        return _SimpleITK.GaborImageSource_SetOrigin(self, Origin)

    def GetOrigin(self):
        r"""GetOrigin(GaborImageSource self) -> VectorDouble"""
        return _SimpleITK.GaborImageSource_GetOrigin(self)

    def SetSpacing(self, Spacing):
        r"""SetSpacing(GaborImageSource self, VectorDouble Spacing)"""
        return _SimpleITK.GaborImageSource_SetSpacing(self, Spacing)

    def GetSpacing(self):
        r"""GetSpacing(GaborImageSource self) -> VectorDouble"""
        return _SimpleITK.GaborImageSource_GetSpacing(self)

    def SetDirection(self, Direction):
        r"""SetDirection(GaborImageSource self, VectorDouble Direction)"""
        return _SimpleITK.GaborImageSource_SetDirection(self, Direction)

    def GetDirection(self):
        r"""GetDirection(GaborImageSource self) -> VectorDouble"""
        return _SimpleITK.GaborImageSource_GetDirection(self)

    def GetName(self):
        r"""GetName(GaborImageSource self) -> std::string"""
        return _SimpleITK.GaborImageSource_GetName(self)

    def __str__(self):
        r"""__str__(GaborImageSource self) -> std::string"""
        return _SimpleITK.GaborImageSource___str__(self)

    def Execute(self):
        r"""Execute(GaborImageSource self) -> Image"""
        return _SimpleITK.GaborImageSource_Execute(self)

# Register GaborImageSource in _SimpleITK:
_SimpleITK.GaborImageSource_swigregister(GaborImageSource)

def GaborSource(*args, **kwargs):
    r"""GaborSource(slicer_itk::simple::PixelIDValueEnum outputPixelType=sitkFloat32, VectorUInt32 size=std::vector< unsigned int >(3, 64), VectorDouble sigma=std::vector< double >(3, 16.0), VectorDouble mean=std::vector< double >(3, 32.0), double frequency=0.4, VectorDouble origin=std::vector< double >(3, 0.0), VectorDouble spacing=std::vector< double >(3, 1.0), VectorDouble direction=std::vector< double >()) -> Image"""
    return _SimpleITK.GaborSource(*args, **kwargs)
class GaussianImageSource(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::GaussianImageSource class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_GaussianImageSource

    def __init__(self):
        r"""__init__(GaussianImageSource self) -> GaussianImageSource"""
        _SimpleITK.GaussianImageSource_swiginit(self, _SimpleITK.new_GaussianImageSource())

    def SetOutputPixelType(self, OutputPixelType):
        r"""SetOutputPixelType(GaussianImageSource self, slicer_itk::simple::PixelIDValueEnum OutputPixelType)"""
        return _SimpleITK.GaussianImageSource_SetOutputPixelType(self, OutputPixelType)

    def GetOutputPixelType(self):
        r"""GetOutputPixelType(GaussianImageSource self) -> slicer_itk::simple::PixelIDValueEnum"""
        return _SimpleITK.GaussianImageSource_GetOutputPixelType(self)

    def SetSize(self, Size):
        r"""SetSize(GaussianImageSource self, VectorUInt32 Size)"""
        return _SimpleITK.GaussianImageSource_SetSize(self, Size)

    def GetSize(self):
        r"""GetSize(GaussianImageSource self) -> VectorUInt32"""
        return _SimpleITK.GaussianImageSource_GetSize(self)

    def SetSigma(self, *args):
        r"""
        SetSigma(GaussianImageSource self, VectorDouble Sigma)
        SetSigma(GaussianImageSource self, double value)
        """
        return _SimpleITK.GaussianImageSource_SetSigma(self, *args)

    def GetSigma(self):
        r"""GetSigma(GaussianImageSource self) -> VectorDouble"""
        return _SimpleITK.GaussianImageSource_GetSigma(self)

    def SetMean(self, *args):
        r"""
        SetMean(GaussianImageSource self, VectorDouble Mean)
        SetMean(GaussianImageSource self, double value)
        """
        return _SimpleITK.GaussianImageSource_SetMean(self, *args)

    def GetMean(self):
        r"""GetMean(GaussianImageSource self) -> VectorDouble"""
        return _SimpleITK.GaussianImageSource_GetMean(self)

    def SetScale(self, Scale):
        r"""SetScale(GaussianImageSource self, double Scale)"""
        return _SimpleITK.GaussianImageSource_SetScale(self, Scale)

    def GetScale(self):
        r"""GetScale(GaussianImageSource self) -> double"""
        return _SimpleITK.GaussianImageSource_GetScale(self)

    def SetOrigin(self, Origin):
        r"""SetOrigin(GaussianImageSource self, VectorDouble Origin)"""
        return _SimpleITK.GaussianImageSource_SetOrigin(self, Origin)

    def GetOrigin(self):
        r"""GetOrigin(GaussianImageSource self) -> VectorDouble"""
        return _SimpleITK.GaussianImageSource_GetOrigin(self)

    def SetSpacing(self, Spacing):
        r"""SetSpacing(GaussianImageSource self, VectorDouble Spacing)"""
        return _SimpleITK.GaussianImageSource_SetSpacing(self, Spacing)

    def GetSpacing(self):
        r"""GetSpacing(GaussianImageSource self) -> VectorDouble"""
        return _SimpleITK.GaussianImageSource_GetSpacing(self)

    def SetDirection(self, Direction):
        r"""SetDirection(GaussianImageSource self, VectorDouble Direction)"""
        return _SimpleITK.GaussianImageSource_SetDirection(self, Direction)

    def GetDirection(self):
        r"""GetDirection(GaussianImageSource self) -> VectorDouble"""
        return _SimpleITK.GaussianImageSource_GetDirection(self)

    def SetNormalized(self, Normalized):
        r"""SetNormalized(GaussianImageSource self, bool Normalized)"""
        return _SimpleITK.GaussianImageSource_SetNormalized(self, Normalized)

    def NormalizedOn(self):
        r"""NormalizedOn(GaussianImageSource self)"""
        return _SimpleITK.GaussianImageSource_NormalizedOn(self)

    def NormalizedOff(self):
        r"""NormalizedOff(GaussianImageSource self)"""
        return _SimpleITK.GaussianImageSource_NormalizedOff(self)

    def GetNormalized(self):
        r"""GetNormalized(GaussianImageSource self) -> bool"""
        return _SimpleITK.GaussianImageSource_GetNormalized(self)

    def GetName(self):
        r"""GetName(GaussianImageSource self) -> std::string"""
        return _SimpleITK.GaussianImageSource_GetName(self)

    def __str__(self):
        r"""__str__(GaussianImageSource self) -> std::string"""
        return _SimpleITK.GaussianImageSource___str__(self)

    def Execute(self):
        r"""Execute(GaussianImageSource self) -> Image"""
        return _SimpleITK.GaussianImageSource_Execute(self)

# Register GaussianImageSource in _SimpleITK:
_SimpleITK.GaussianImageSource_swigregister(GaussianImageSource)

def GaussianSource(*args, **kwargs):
    r"""GaussianSource(slicer_itk::simple::PixelIDValueEnum outputPixelType=sitkFloat32, VectorUInt32 size=std::vector< unsigned int >(3, 64), VectorDouble sigma=std::vector< double >(3, 16.0), VectorDouble mean=std::vector< double >(3, 32.0), double scale=255, VectorDouble origin=std::vector< double >(3, 0.0), VectorDouble spacing=std::vector< double >(3, 1.0), VectorDouble direction=std::vector< double >(), bool normalized=False) -> Image"""
    return _SimpleITK.GaussianSource(*args, **kwargs)
class GeodesicActiveContourLevelSetImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::GeodesicActiveContourLevelSetImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_GeodesicActiveContourLevelSetImageFilter

    def __init__(self):
        r"""__init__(GeodesicActiveContourLevelSetImageFilter self) -> GeodesicActiveContourLevelSetImageFilter"""
        _SimpleITK.GeodesicActiveContourLevelSetImageFilter_swiginit(self, _SimpleITK.new_GeodesicActiveContourLevelSetImageFilter())

    def SetMaximumRMSError(self, MaximumRMSError):
        r"""SetMaximumRMSError(GeodesicActiveContourLevelSetImageFilter self, double MaximumRMSError)"""
        return _SimpleITK.GeodesicActiveContourLevelSetImageFilter_SetMaximumRMSError(self, MaximumRMSError)

    def GetMaximumRMSError(self):
        r"""GetMaximumRMSError(GeodesicActiveContourLevelSetImageFilter self) -> double"""
        return _SimpleITK.GeodesicActiveContourLevelSetImageFilter_GetMaximumRMSError(self)

    def SetPropagationScaling(self, PropagationScaling):
        r"""SetPropagationScaling(GeodesicActiveContourLevelSetImageFilter self, double PropagationScaling)"""
        return _SimpleITK.GeodesicActiveContourLevelSetImageFilter_SetPropagationScaling(self, PropagationScaling)

    def GetPropagationScaling(self):
        r"""GetPropagationScaling(GeodesicActiveContourLevelSetImageFilter self) -> double"""
        return _SimpleITK.GeodesicActiveContourLevelSetImageFilter_GetPropagationScaling(self)

    def SetCurvatureScaling(self, CurvatureScaling):
        r"""SetCurvatureScaling(GeodesicActiveContourLevelSetImageFilter self, double CurvatureScaling)"""
        return _SimpleITK.GeodesicActiveContourLevelSetImageFilter_SetCurvatureScaling(self, CurvatureScaling)

    def GetCurvatureScaling(self):
        r"""GetCurvatureScaling(GeodesicActiveContourLevelSetImageFilter self) -> double"""
        return _SimpleITK.GeodesicActiveContourLevelSetImageFilter_GetCurvatureScaling(self)

    def SetAdvectionScaling(self, AdvectionScaling):
        r"""SetAdvectionScaling(GeodesicActiveContourLevelSetImageFilter self, double AdvectionScaling)"""
        return _SimpleITK.GeodesicActiveContourLevelSetImageFilter_SetAdvectionScaling(self, AdvectionScaling)

    def GetAdvectionScaling(self):
        r"""GetAdvectionScaling(GeodesicActiveContourLevelSetImageFilter self) -> double"""
        return _SimpleITK.GeodesicActiveContourLevelSetImageFilter_GetAdvectionScaling(self)

    def SetNumberOfIterations(self, NumberOfIterations):
        r"""SetNumberOfIterations(GeodesicActiveContourLevelSetImageFilter self, uint32_t NumberOfIterations)"""
        return _SimpleITK.GeodesicActiveContourLevelSetImageFilter_SetNumberOfIterations(self, NumberOfIterations)

    def GetNumberOfIterations(self):
        r"""GetNumberOfIterations(GeodesicActiveContourLevelSetImageFilter self) -> uint32_t"""
        return _SimpleITK.GeodesicActiveContourLevelSetImageFilter_GetNumberOfIterations(self)

    def SetReverseExpansionDirection(self, ReverseExpansionDirection):
        r"""SetReverseExpansionDirection(GeodesicActiveContourLevelSetImageFilter self, bool ReverseExpansionDirection)"""
        return _SimpleITK.GeodesicActiveContourLevelSetImageFilter_SetReverseExpansionDirection(self, ReverseExpansionDirection)

    def ReverseExpansionDirectionOn(self):
        r"""ReverseExpansionDirectionOn(GeodesicActiveContourLevelSetImageFilter self)"""
        return _SimpleITK.GeodesicActiveContourLevelSetImageFilter_ReverseExpansionDirectionOn(self)

    def ReverseExpansionDirectionOff(self):
        r"""ReverseExpansionDirectionOff(GeodesicActiveContourLevelSetImageFilter self)"""
        return _SimpleITK.GeodesicActiveContourLevelSetImageFilter_ReverseExpansionDirectionOff(self)

    def GetReverseExpansionDirection(self):
        r"""GetReverseExpansionDirection(GeodesicActiveContourLevelSetImageFilter self) -> bool"""
        return _SimpleITK.GeodesicActiveContourLevelSetImageFilter_GetReverseExpansionDirection(self)

    def GetElapsedIterations(self):
        r"""GetElapsedIterations(GeodesicActiveContourLevelSetImageFilter self) -> uint32_t"""
        return _SimpleITK.GeodesicActiveContourLevelSetImageFilter_GetElapsedIterations(self)

    def GetRMSChange(self):
        r"""GetRMSChange(GeodesicActiveContourLevelSetImageFilter self) -> double"""
        return _SimpleITK.GeodesicActiveContourLevelSetImageFilter_GetRMSChange(self)

    def GetName(self):
        r"""GetName(GeodesicActiveContourLevelSetImageFilter self) -> std::string"""
        return _SimpleITK.GeodesicActiveContourLevelSetImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(GeodesicActiveContourLevelSetImageFilter self) -> std::string"""
        return _SimpleITK.GeodesicActiveContourLevelSetImageFilter___str__(self)

    def Execute(self, initialImage, featureImage):
        r"""Execute(GeodesicActiveContourLevelSetImageFilter self, Image initialImage, Image featureImage) -> Image"""
        return _SimpleITK.GeodesicActiveContourLevelSetImageFilter_Execute(self, initialImage, featureImage)

# Register GeodesicActiveContourLevelSetImageFilter in _SimpleITK:
_SimpleITK.GeodesicActiveContourLevelSetImageFilter_swigregister(GeodesicActiveContourLevelSetImageFilter)

def GeodesicActiveContourLevelSet(initialImage, featureImage, maximumRMSError=0.01, propagationScaling=1.0, curvatureScaling=1.0, advectionScaling=1.0, numberOfIterations=1000, reverseExpansionDirection=False):
    r"""GeodesicActiveContourLevelSet(Image initialImage, Image featureImage, double maximumRMSError=0.01, double propagationScaling=1.0, double curvatureScaling=1.0, double advectionScaling=1.0, uint32_t numberOfIterations=1000, bool reverseExpansionDirection=False) -> Image"""
    return _SimpleITK.GeodesicActiveContourLevelSet(initialImage, featureImage, maximumRMSError, propagationScaling, curvatureScaling, advectionScaling, numberOfIterations, reverseExpansionDirection)
class GradientAnisotropicDiffusionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::GradientAnisotropicDiffusionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_GradientAnisotropicDiffusionImageFilter

    def __init__(self):
        r"""__init__(GradientAnisotropicDiffusionImageFilter self) -> GradientAnisotropicDiffusionImageFilter"""
        _SimpleITK.GradientAnisotropicDiffusionImageFilter_swiginit(self, _SimpleITK.new_GradientAnisotropicDiffusionImageFilter())

    def SetTimeStep(self, TimeStep):
        r"""SetTimeStep(GradientAnisotropicDiffusionImageFilter self, double TimeStep)"""
        return _SimpleITK.GradientAnisotropicDiffusionImageFilter_SetTimeStep(self, TimeStep)

    def GetTimeStep(self):
        r"""GetTimeStep(GradientAnisotropicDiffusionImageFilter self) -> double"""
        return _SimpleITK.GradientAnisotropicDiffusionImageFilter_GetTimeStep(self)

    def SetConductanceParameter(self, ConductanceParameter):
        r"""SetConductanceParameter(GradientAnisotropicDiffusionImageFilter self, double ConductanceParameter)"""
        return _SimpleITK.GradientAnisotropicDiffusionImageFilter_SetConductanceParameter(self, ConductanceParameter)

    def GetConductanceParameter(self):
        r"""GetConductanceParameter(GradientAnisotropicDiffusionImageFilter self) -> double"""
        return _SimpleITK.GradientAnisotropicDiffusionImageFilter_GetConductanceParameter(self)

    def SetConductanceScalingUpdateInterval(self, ConductanceScalingUpdateInterval):
        r"""SetConductanceScalingUpdateInterval(GradientAnisotropicDiffusionImageFilter self, unsigned int ConductanceScalingUpdateInterval)"""
        return _SimpleITK.GradientAnisotropicDiffusionImageFilter_SetConductanceScalingUpdateInterval(self, ConductanceScalingUpdateInterval)

    def GetConductanceScalingUpdateInterval(self):
        r"""GetConductanceScalingUpdateInterval(GradientAnisotropicDiffusionImageFilter self) -> unsigned int"""
        return _SimpleITK.GradientAnisotropicDiffusionImageFilter_GetConductanceScalingUpdateInterval(self)

    def SetNumberOfIterations(self, NumberOfIterations):
        r"""SetNumberOfIterations(GradientAnisotropicDiffusionImageFilter self, uint32_t NumberOfIterations)"""
        return _SimpleITK.GradientAnisotropicDiffusionImageFilter_SetNumberOfIterations(self, NumberOfIterations)

    def GetNumberOfIterations(self):
        r"""GetNumberOfIterations(GradientAnisotropicDiffusionImageFilter self) -> uint32_t"""
        return _SimpleITK.GradientAnisotropicDiffusionImageFilter_GetNumberOfIterations(self)

    def GetName(self):
        r"""GetName(GradientAnisotropicDiffusionImageFilter self) -> std::string"""
        return _SimpleITK.GradientAnisotropicDiffusionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(GradientAnisotropicDiffusionImageFilter self) -> std::string"""
        return _SimpleITK.GradientAnisotropicDiffusionImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(GradientAnisotropicDiffusionImageFilter self, Image image1) -> Image"""
        return _SimpleITK.GradientAnisotropicDiffusionImageFilter_Execute(self, image1)

    def EstimateOptimalTimeStep(self, inImage):
        r"""EstimateOptimalTimeStep(GradientAnisotropicDiffusionImageFilter self, Image inImage) -> double"""
        return _SimpleITK.GradientAnisotropicDiffusionImageFilter_EstimateOptimalTimeStep(self, inImage)

# Register GradientAnisotropicDiffusionImageFilter in _SimpleITK:
_SimpleITK.GradientAnisotropicDiffusionImageFilter_swigregister(GradientAnisotropicDiffusionImageFilter)

def GradientAnisotropicDiffusion(image1, timeStep=0.125, conductanceParameter=3, conductanceScalingUpdateInterval=1, numberOfIterations=5):
    r"""GradientAnisotropicDiffusion(Image image1, double timeStep=0.125, double conductanceParameter=3, unsigned int conductanceScalingUpdateInterval=1, uint32_t numberOfIterations=5) -> Image"""
    return _SimpleITK.GradientAnisotropicDiffusion(image1, timeStep, conductanceParameter, conductanceScalingUpdateInterval, numberOfIterations)
class GradientImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::GradientImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_GradientImageFilter

    def __init__(self):
        r"""__init__(GradientImageFilter self) -> GradientImageFilter"""
        _SimpleITK.GradientImageFilter_swiginit(self, _SimpleITK.new_GradientImageFilter())

    def SetUseImageSpacing(self, UseImageSpacing):
        r"""SetUseImageSpacing(GradientImageFilter self, bool UseImageSpacing)"""
        return _SimpleITK.GradientImageFilter_SetUseImageSpacing(self, UseImageSpacing)

    def UseImageSpacingOn(self):
        r"""UseImageSpacingOn(GradientImageFilter self)"""
        return _SimpleITK.GradientImageFilter_UseImageSpacingOn(self)

    def UseImageSpacingOff(self):
        r"""UseImageSpacingOff(GradientImageFilter self)"""
        return _SimpleITK.GradientImageFilter_UseImageSpacingOff(self)

    def GetUseImageSpacing(self):
        r"""GetUseImageSpacing(GradientImageFilter self) -> bool"""
        return _SimpleITK.GradientImageFilter_GetUseImageSpacing(self)

    def SetUseImageDirection(self, UseImageDirection):
        r"""SetUseImageDirection(GradientImageFilter self, bool UseImageDirection)"""
        return _SimpleITK.GradientImageFilter_SetUseImageDirection(self, UseImageDirection)

    def UseImageDirectionOn(self):
        r"""UseImageDirectionOn(GradientImageFilter self)"""
        return _SimpleITK.GradientImageFilter_UseImageDirectionOn(self)

    def UseImageDirectionOff(self):
        r"""UseImageDirectionOff(GradientImageFilter self)"""
        return _SimpleITK.GradientImageFilter_UseImageDirectionOff(self)

    def GetUseImageDirection(self):
        r"""GetUseImageDirection(GradientImageFilter self) -> bool"""
        return _SimpleITK.GradientImageFilter_GetUseImageDirection(self)

    def GetName(self):
        r"""GetName(GradientImageFilter self) -> std::string"""
        return _SimpleITK.GradientImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(GradientImageFilter self) -> std::string"""
        return _SimpleITK.GradientImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(GradientImageFilter self, Image image1) -> Image"""
        return _SimpleITK.GradientImageFilter_Execute(self, image1)

# Register GradientImageFilter in _SimpleITK:
_SimpleITK.GradientImageFilter_swigregister(GradientImageFilter)

def Gradient(image1, useImageSpacing=True, useImageDirection=False):
    r"""Gradient(Image image1, bool useImageSpacing=True, bool useImageDirection=False) -> Image"""
    return _SimpleITK.Gradient(image1, useImageSpacing, useImageDirection)
class GradientMagnitudeImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::GradientMagnitudeImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_GradientMagnitudeImageFilter

    def __init__(self):
        r"""__init__(GradientMagnitudeImageFilter self) -> GradientMagnitudeImageFilter"""
        _SimpleITK.GradientMagnitudeImageFilter_swiginit(self, _SimpleITK.new_GradientMagnitudeImageFilter())

    def SetUseImageSpacing(self, UseImageSpacing):
        r"""SetUseImageSpacing(GradientMagnitudeImageFilter self, bool UseImageSpacing)"""
        return _SimpleITK.GradientMagnitudeImageFilter_SetUseImageSpacing(self, UseImageSpacing)

    def UseImageSpacingOn(self):
        r"""UseImageSpacingOn(GradientMagnitudeImageFilter self)"""
        return _SimpleITK.GradientMagnitudeImageFilter_UseImageSpacingOn(self)

    def UseImageSpacingOff(self):
        r"""UseImageSpacingOff(GradientMagnitudeImageFilter self)"""
        return _SimpleITK.GradientMagnitudeImageFilter_UseImageSpacingOff(self)

    def GetUseImageSpacing(self):
        r"""GetUseImageSpacing(GradientMagnitudeImageFilter self) -> bool"""
        return _SimpleITK.GradientMagnitudeImageFilter_GetUseImageSpacing(self)

    def GetName(self):
        r"""GetName(GradientMagnitudeImageFilter self) -> std::string"""
        return _SimpleITK.GradientMagnitudeImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(GradientMagnitudeImageFilter self) -> std::string"""
        return _SimpleITK.GradientMagnitudeImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(GradientMagnitudeImageFilter self, Image image1) -> Image"""
        return _SimpleITK.GradientMagnitudeImageFilter_Execute(self, image1)

# Register GradientMagnitudeImageFilter in _SimpleITK:
_SimpleITK.GradientMagnitudeImageFilter_swigregister(GradientMagnitudeImageFilter)

def GradientMagnitude(image1, useImageSpacing=True):
    r"""GradientMagnitude(Image image1, bool useImageSpacing=True) -> Image"""
    return _SimpleITK.GradientMagnitude(image1, useImageSpacing)
class GradientMagnitudeRecursiveGaussianImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::GradientMagnitudeRecursiveGaussianImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_GradientMagnitudeRecursiveGaussianImageFilter

    def __init__(self):
        r"""__init__(GradientMagnitudeRecursiveGaussianImageFilter self) -> GradientMagnitudeRecursiveGaussianImageFilter"""
        _SimpleITK.GradientMagnitudeRecursiveGaussianImageFilter_swiginit(self, _SimpleITK.new_GradientMagnitudeRecursiveGaussianImageFilter())

    def SetSigma(self, Sigma):
        r"""SetSigma(GradientMagnitudeRecursiveGaussianImageFilter self, double Sigma)"""
        return _SimpleITK.GradientMagnitudeRecursiveGaussianImageFilter_SetSigma(self, Sigma)

    def GetSigma(self):
        r"""GetSigma(GradientMagnitudeRecursiveGaussianImageFilter self) -> double"""
        return _SimpleITK.GradientMagnitudeRecursiveGaussianImageFilter_GetSigma(self)

    def SetNormalizeAcrossScale(self, NormalizeAcrossScale):
        r"""SetNormalizeAcrossScale(GradientMagnitudeRecursiveGaussianImageFilter self, bool NormalizeAcrossScale)"""
        return _SimpleITK.GradientMagnitudeRecursiveGaussianImageFilter_SetNormalizeAcrossScale(self, NormalizeAcrossScale)

    def NormalizeAcrossScaleOn(self):
        r"""NormalizeAcrossScaleOn(GradientMagnitudeRecursiveGaussianImageFilter self)"""
        return _SimpleITK.GradientMagnitudeRecursiveGaussianImageFilter_NormalizeAcrossScaleOn(self)

    def NormalizeAcrossScaleOff(self):
        r"""NormalizeAcrossScaleOff(GradientMagnitudeRecursiveGaussianImageFilter self)"""
        return _SimpleITK.GradientMagnitudeRecursiveGaussianImageFilter_NormalizeAcrossScaleOff(self)

    def GetNormalizeAcrossScale(self):
        r"""GetNormalizeAcrossScale(GradientMagnitudeRecursiveGaussianImageFilter self) -> bool"""
        return _SimpleITK.GradientMagnitudeRecursiveGaussianImageFilter_GetNormalizeAcrossScale(self)

    def GetName(self):
        r"""GetName(GradientMagnitudeRecursiveGaussianImageFilter self) -> std::string"""
        return _SimpleITK.GradientMagnitudeRecursiveGaussianImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(GradientMagnitudeRecursiveGaussianImageFilter self) -> std::string"""
        return _SimpleITK.GradientMagnitudeRecursiveGaussianImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(GradientMagnitudeRecursiveGaussianImageFilter self, Image image1) -> Image"""
        return _SimpleITK.GradientMagnitudeRecursiveGaussianImageFilter_Execute(self, image1)

# Register GradientMagnitudeRecursiveGaussianImageFilter in _SimpleITK:
_SimpleITK.GradientMagnitudeRecursiveGaussianImageFilter_swigregister(GradientMagnitudeRecursiveGaussianImageFilter)

def GradientMagnitudeRecursiveGaussian(image1, sigma=1.0, normalizeAcrossScale=False):
    r"""GradientMagnitudeRecursiveGaussian(Image image1, double sigma=1.0, bool normalizeAcrossScale=False) -> Image"""
    return _SimpleITK.GradientMagnitudeRecursiveGaussian(image1, sigma, normalizeAcrossScale)
class GradientRecursiveGaussianImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::GradientRecursiveGaussianImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_GradientRecursiveGaussianImageFilter

    def __init__(self):
        r"""__init__(GradientRecursiveGaussianImageFilter self) -> GradientRecursiveGaussianImageFilter"""
        _SimpleITK.GradientRecursiveGaussianImageFilter_swiginit(self, _SimpleITK.new_GradientRecursiveGaussianImageFilter())

    def SetSigma(self, Sigma):
        r"""SetSigma(GradientRecursiveGaussianImageFilter self, double Sigma)"""
        return _SimpleITK.GradientRecursiveGaussianImageFilter_SetSigma(self, Sigma)

    def GetSigma(self):
        r"""GetSigma(GradientRecursiveGaussianImageFilter self) -> double"""
        return _SimpleITK.GradientRecursiveGaussianImageFilter_GetSigma(self)

    def SetNormalizeAcrossScale(self, NormalizeAcrossScale):
        r"""SetNormalizeAcrossScale(GradientRecursiveGaussianImageFilter self, bool NormalizeAcrossScale)"""
        return _SimpleITK.GradientRecursiveGaussianImageFilter_SetNormalizeAcrossScale(self, NormalizeAcrossScale)

    def NormalizeAcrossScaleOn(self):
        r"""NormalizeAcrossScaleOn(GradientRecursiveGaussianImageFilter self)"""
        return _SimpleITK.GradientRecursiveGaussianImageFilter_NormalizeAcrossScaleOn(self)

    def NormalizeAcrossScaleOff(self):
        r"""NormalizeAcrossScaleOff(GradientRecursiveGaussianImageFilter self)"""
        return _SimpleITK.GradientRecursiveGaussianImageFilter_NormalizeAcrossScaleOff(self)

    def GetNormalizeAcrossScale(self):
        r"""GetNormalizeAcrossScale(GradientRecursiveGaussianImageFilter self) -> bool"""
        return _SimpleITK.GradientRecursiveGaussianImageFilter_GetNormalizeAcrossScale(self)

    def SetUseImageDirection(self, UseImageDirection):
        r"""SetUseImageDirection(GradientRecursiveGaussianImageFilter self, bool UseImageDirection)"""
        return _SimpleITK.GradientRecursiveGaussianImageFilter_SetUseImageDirection(self, UseImageDirection)

    def UseImageDirectionOn(self):
        r"""UseImageDirectionOn(GradientRecursiveGaussianImageFilter self)"""
        return _SimpleITK.GradientRecursiveGaussianImageFilter_UseImageDirectionOn(self)

    def UseImageDirectionOff(self):
        r"""UseImageDirectionOff(GradientRecursiveGaussianImageFilter self)"""
        return _SimpleITK.GradientRecursiveGaussianImageFilter_UseImageDirectionOff(self)

    def GetUseImageDirection(self):
        r"""GetUseImageDirection(GradientRecursiveGaussianImageFilter self) -> bool"""
        return _SimpleITK.GradientRecursiveGaussianImageFilter_GetUseImageDirection(self)

    def GetName(self):
        r"""GetName(GradientRecursiveGaussianImageFilter self) -> std::string"""
        return _SimpleITK.GradientRecursiveGaussianImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(GradientRecursiveGaussianImageFilter self) -> std::string"""
        return _SimpleITK.GradientRecursiveGaussianImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(GradientRecursiveGaussianImageFilter self, Image image1) -> Image"""
        return _SimpleITK.GradientRecursiveGaussianImageFilter_Execute(self, image1)

# Register GradientRecursiveGaussianImageFilter in _SimpleITK:
_SimpleITK.GradientRecursiveGaussianImageFilter_swigregister(GradientRecursiveGaussianImageFilter)

def GradientRecursiveGaussian(image1, sigma=1.0, normalizeAcrossScale=False, useImageDirection=False):
    r"""GradientRecursiveGaussian(Image image1, double sigma=1.0, bool normalizeAcrossScale=False, bool useImageDirection=False) -> Image"""
    return _SimpleITK.GradientRecursiveGaussian(image1, sigma, normalizeAcrossScale, useImageDirection)
class GrayscaleConnectedClosingImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::GrayscaleConnectedClosingImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_GrayscaleConnectedClosingImageFilter

    def __init__(self):
        r"""__init__(GrayscaleConnectedClosingImageFilter self) -> GrayscaleConnectedClosingImageFilter"""
        _SimpleITK.GrayscaleConnectedClosingImageFilter_swiginit(self, _SimpleITK.new_GrayscaleConnectedClosingImageFilter())

    def SetSeed(self, Seed):
        r"""SetSeed(GrayscaleConnectedClosingImageFilter self, VectorUInt32 Seed)"""
        return _SimpleITK.GrayscaleConnectedClosingImageFilter_SetSeed(self, Seed)

    def GetSeed(self):
        r"""GetSeed(GrayscaleConnectedClosingImageFilter self) -> VectorUInt32"""
        return _SimpleITK.GrayscaleConnectedClosingImageFilter_GetSeed(self)

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(GrayscaleConnectedClosingImageFilter self, bool FullyConnected)"""
        return _SimpleITK.GrayscaleConnectedClosingImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(GrayscaleConnectedClosingImageFilter self)"""
        return _SimpleITK.GrayscaleConnectedClosingImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(GrayscaleConnectedClosingImageFilter self)"""
        return _SimpleITK.GrayscaleConnectedClosingImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(GrayscaleConnectedClosingImageFilter self) -> bool"""
        return _SimpleITK.GrayscaleConnectedClosingImageFilter_GetFullyConnected(self)

    def GetName(self):
        r"""GetName(GrayscaleConnectedClosingImageFilter self) -> std::string"""
        return _SimpleITK.GrayscaleConnectedClosingImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(GrayscaleConnectedClosingImageFilter self) -> std::string"""
        return _SimpleITK.GrayscaleConnectedClosingImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(GrayscaleConnectedClosingImageFilter self, Image image1) -> Image"""
        return _SimpleITK.GrayscaleConnectedClosingImageFilter_Execute(self, image1)

# Register GrayscaleConnectedClosingImageFilter in _SimpleITK:
_SimpleITK.GrayscaleConnectedClosingImageFilter_swigregister(GrayscaleConnectedClosingImageFilter)

def GrayscaleConnectedClosing(*args, **kwargs):
    r"""GrayscaleConnectedClosing(Image image1, VectorUInt32 seed=std::vector< uint32_t >(3, 0), bool fullyConnected=False) -> Image"""
    return _SimpleITK.GrayscaleConnectedClosing(*args, **kwargs)
class GrayscaleConnectedOpeningImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::GrayscaleConnectedOpeningImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_GrayscaleConnectedOpeningImageFilter

    def __init__(self):
        r"""__init__(GrayscaleConnectedOpeningImageFilter self) -> GrayscaleConnectedOpeningImageFilter"""
        _SimpleITK.GrayscaleConnectedOpeningImageFilter_swiginit(self, _SimpleITK.new_GrayscaleConnectedOpeningImageFilter())

    def SetSeed(self, Seed):
        r"""SetSeed(GrayscaleConnectedOpeningImageFilter self, VectorUInt32 Seed)"""
        return _SimpleITK.GrayscaleConnectedOpeningImageFilter_SetSeed(self, Seed)

    def GetSeed(self):
        r"""GetSeed(GrayscaleConnectedOpeningImageFilter self) -> VectorUInt32"""
        return _SimpleITK.GrayscaleConnectedOpeningImageFilter_GetSeed(self)

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(GrayscaleConnectedOpeningImageFilter self, bool FullyConnected)"""
        return _SimpleITK.GrayscaleConnectedOpeningImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(GrayscaleConnectedOpeningImageFilter self)"""
        return _SimpleITK.GrayscaleConnectedOpeningImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(GrayscaleConnectedOpeningImageFilter self)"""
        return _SimpleITK.GrayscaleConnectedOpeningImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(GrayscaleConnectedOpeningImageFilter self) -> bool"""
        return _SimpleITK.GrayscaleConnectedOpeningImageFilter_GetFullyConnected(self)

    def GetName(self):
        r"""GetName(GrayscaleConnectedOpeningImageFilter self) -> std::string"""
        return _SimpleITK.GrayscaleConnectedOpeningImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(GrayscaleConnectedOpeningImageFilter self) -> std::string"""
        return _SimpleITK.GrayscaleConnectedOpeningImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(GrayscaleConnectedOpeningImageFilter self, Image image1) -> Image"""
        return _SimpleITK.GrayscaleConnectedOpeningImageFilter_Execute(self, image1)

# Register GrayscaleConnectedOpeningImageFilter in _SimpleITK:
_SimpleITK.GrayscaleConnectedOpeningImageFilter_swigregister(GrayscaleConnectedOpeningImageFilter)

def GrayscaleConnectedOpening(*args, **kwargs):
    r"""GrayscaleConnectedOpening(Image image1, VectorUInt32 seed=std::vector< unsigned int >(3, 0), bool fullyConnected=False) -> Image"""
    return _SimpleITK.GrayscaleConnectedOpening(*args, **kwargs)
class GrayscaleDilateImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::GrayscaleDilateImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_GrayscaleDilateImageFilter

    def __init__(self):
        r"""__init__(GrayscaleDilateImageFilter self) -> GrayscaleDilateImageFilter"""
        _SimpleITK.GrayscaleDilateImageFilter_swiginit(self, _SimpleITK.new_GrayscaleDilateImageFilter())

    def SetKernelRadius(self, *args):
        r"""
        SetKernelRadius(GrayscaleDilateImageFilter self, VectorUInt32 KernelRadius)
        SetKernelRadius(GrayscaleDilateImageFilter self, unsigned int value)
        """
        return _SimpleITK.GrayscaleDilateImageFilter_SetKernelRadius(self, *args)

    def GetKernelRadius(self):
        r"""GetKernelRadius(GrayscaleDilateImageFilter self) -> VectorUInt32"""
        return _SimpleITK.GrayscaleDilateImageFilter_GetKernelRadius(self)

    def SetKernelType(self, KernelType):
        r"""SetKernelType(GrayscaleDilateImageFilter self, slicer_itk::simple::KernelEnum KernelType)"""
        return _SimpleITK.GrayscaleDilateImageFilter_SetKernelType(self, KernelType)

    def GetKernelType(self):
        r"""GetKernelType(GrayscaleDilateImageFilter self) -> slicer_itk::simple::KernelEnum"""
        return _SimpleITK.GrayscaleDilateImageFilter_GetKernelType(self)

    def GetName(self):
        r"""GetName(GrayscaleDilateImageFilter self) -> std::string"""
        return _SimpleITK.GrayscaleDilateImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(GrayscaleDilateImageFilter self) -> std::string"""
        return _SimpleITK.GrayscaleDilateImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(GrayscaleDilateImageFilter self, Image image1) -> Image"""
        return _SimpleITK.GrayscaleDilateImageFilter_Execute(self, image1)

# Register GrayscaleDilateImageFilter in _SimpleITK:
_SimpleITK.GrayscaleDilateImageFilter_swigregister(GrayscaleDilateImageFilter)

def GrayscaleDilate(*args, **kwargs):
    r"""GrayscaleDilate(Image image1, VectorUInt32 kernelRadius=std::vector< uint32_t >(3, 1), slicer_itk::simple::KernelEnum kernelType=sitkBall) -> Image"""
    return _SimpleITK.GrayscaleDilate(*args, **kwargs)
class GrayscaleErodeImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::GrayscaleErodeImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_GrayscaleErodeImageFilter

    def __init__(self):
        r"""__init__(GrayscaleErodeImageFilter self) -> GrayscaleErodeImageFilter"""
        _SimpleITK.GrayscaleErodeImageFilter_swiginit(self, _SimpleITK.new_GrayscaleErodeImageFilter())

    def SetKernelRadius(self, *args):
        r"""
        SetKernelRadius(GrayscaleErodeImageFilter self, VectorUInt32 KernelRadius)
        SetKernelRadius(GrayscaleErodeImageFilter self, unsigned int value)
        """
        return _SimpleITK.GrayscaleErodeImageFilter_SetKernelRadius(self, *args)

    def GetKernelRadius(self):
        r"""GetKernelRadius(GrayscaleErodeImageFilter self) -> VectorUInt32"""
        return _SimpleITK.GrayscaleErodeImageFilter_GetKernelRadius(self)

    def SetKernelType(self, KernelType):
        r"""SetKernelType(GrayscaleErodeImageFilter self, slicer_itk::simple::KernelEnum KernelType)"""
        return _SimpleITK.GrayscaleErodeImageFilter_SetKernelType(self, KernelType)

    def GetKernelType(self):
        r"""GetKernelType(GrayscaleErodeImageFilter self) -> slicer_itk::simple::KernelEnum"""
        return _SimpleITK.GrayscaleErodeImageFilter_GetKernelType(self)

    def GetName(self):
        r"""GetName(GrayscaleErodeImageFilter self) -> std::string"""
        return _SimpleITK.GrayscaleErodeImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(GrayscaleErodeImageFilter self) -> std::string"""
        return _SimpleITK.GrayscaleErodeImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(GrayscaleErodeImageFilter self, Image image1) -> Image"""
        return _SimpleITK.GrayscaleErodeImageFilter_Execute(self, image1)

# Register GrayscaleErodeImageFilter in _SimpleITK:
_SimpleITK.GrayscaleErodeImageFilter_swigregister(GrayscaleErodeImageFilter)

def GrayscaleErode(*args, **kwargs):
    r"""GrayscaleErode(Image image1, VectorUInt32 kernelRadius=std::vector< uint32_t >(3, 1), slicer_itk::simple::KernelEnum kernelType=sitkBall) -> Image"""
    return _SimpleITK.GrayscaleErode(*args, **kwargs)
class GrayscaleFillholeImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::GrayscaleFillholeImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_GrayscaleFillholeImageFilter

    def __init__(self):
        r"""__init__(GrayscaleFillholeImageFilter self) -> GrayscaleFillholeImageFilter"""
        _SimpleITK.GrayscaleFillholeImageFilter_swiginit(self, _SimpleITK.new_GrayscaleFillholeImageFilter())

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(GrayscaleFillholeImageFilter self, bool FullyConnected)"""
        return _SimpleITK.GrayscaleFillholeImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(GrayscaleFillholeImageFilter self)"""
        return _SimpleITK.GrayscaleFillholeImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(GrayscaleFillholeImageFilter self)"""
        return _SimpleITK.GrayscaleFillholeImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(GrayscaleFillholeImageFilter self) -> bool"""
        return _SimpleITK.GrayscaleFillholeImageFilter_GetFullyConnected(self)

    def GetName(self):
        r"""GetName(GrayscaleFillholeImageFilter self) -> std::string"""
        return _SimpleITK.GrayscaleFillholeImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(GrayscaleFillholeImageFilter self) -> std::string"""
        return _SimpleITK.GrayscaleFillholeImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(GrayscaleFillholeImageFilter self, Image image1) -> Image"""
        return _SimpleITK.GrayscaleFillholeImageFilter_Execute(self, image1)

# Register GrayscaleFillholeImageFilter in _SimpleITK:
_SimpleITK.GrayscaleFillholeImageFilter_swigregister(GrayscaleFillholeImageFilter)

def GrayscaleFillhole(image1, fullyConnected=False):
    r"""GrayscaleFillhole(Image image1, bool fullyConnected=False) -> Image"""
    return _SimpleITK.GrayscaleFillhole(image1, fullyConnected)
class GrayscaleGeodesicDilateImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::GrayscaleGeodesicDilateImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_GrayscaleGeodesicDilateImageFilter

    def __init__(self):
        r"""__init__(GrayscaleGeodesicDilateImageFilter self) -> GrayscaleGeodesicDilateImageFilter"""
        _SimpleITK.GrayscaleGeodesicDilateImageFilter_swiginit(self, _SimpleITK.new_GrayscaleGeodesicDilateImageFilter())

    def SetRunOneIteration(self, RunOneIteration):
        r"""SetRunOneIteration(GrayscaleGeodesicDilateImageFilter self, bool RunOneIteration)"""
        return _SimpleITK.GrayscaleGeodesicDilateImageFilter_SetRunOneIteration(self, RunOneIteration)

    def RunOneIterationOn(self):
        r"""RunOneIterationOn(GrayscaleGeodesicDilateImageFilter self)"""
        return _SimpleITK.GrayscaleGeodesicDilateImageFilter_RunOneIterationOn(self)

    def RunOneIterationOff(self):
        r"""RunOneIterationOff(GrayscaleGeodesicDilateImageFilter self)"""
        return _SimpleITK.GrayscaleGeodesicDilateImageFilter_RunOneIterationOff(self)

    def GetRunOneIteration(self):
        r"""GetRunOneIteration(GrayscaleGeodesicDilateImageFilter self) -> bool"""
        return _SimpleITK.GrayscaleGeodesicDilateImageFilter_GetRunOneIteration(self)

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(GrayscaleGeodesicDilateImageFilter self, bool FullyConnected)"""
        return _SimpleITK.GrayscaleGeodesicDilateImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(GrayscaleGeodesicDilateImageFilter self)"""
        return _SimpleITK.GrayscaleGeodesicDilateImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(GrayscaleGeodesicDilateImageFilter self)"""
        return _SimpleITK.GrayscaleGeodesicDilateImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(GrayscaleGeodesicDilateImageFilter self) -> bool"""
        return _SimpleITK.GrayscaleGeodesicDilateImageFilter_GetFullyConnected(self)

    def GetName(self):
        r"""GetName(GrayscaleGeodesicDilateImageFilter self) -> std::string"""
        return _SimpleITK.GrayscaleGeodesicDilateImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(GrayscaleGeodesicDilateImageFilter self) -> std::string"""
        return _SimpleITK.GrayscaleGeodesicDilateImageFilter___str__(self)

    def Execute(self, image1, image2):
        r"""Execute(GrayscaleGeodesicDilateImageFilter self, Image image1, Image image2) -> Image"""
        return _SimpleITK.GrayscaleGeodesicDilateImageFilter_Execute(self, image1, image2)

# Register GrayscaleGeodesicDilateImageFilter in _SimpleITK:
_SimpleITK.GrayscaleGeodesicDilateImageFilter_swigregister(GrayscaleGeodesicDilateImageFilter)

def GrayscaleGeodesicDilate(image1, image2, runOneIteration=False, fullyConnected=False):
    r"""GrayscaleGeodesicDilate(Image image1, Image image2, bool runOneIteration=False, bool fullyConnected=False) -> Image"""
    return _SimpleITK.GrayscaleGeodesicDilate(image1, image2, runOneIteration, fullyConnected)
class GrayscaleGeodesicErodeImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::GrayscaleGeodesicErodeImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_GrayscaleGeodesicErodeImageFilter

    def __init__(self):
        r"""__init__(GrayscaleGeodesicErodeImageFilter self) -> GrayscaleGeodesicErodeImageFilter"""
        _SimpleITK.GrayscaleGeodesicErodeImageFilter_swiginit(self, _SimpleITK.new_GrayscaleGeodesicErodeImageFilter())

    def SetRunOneIteration(self, RunOneIteration):
        r"""SetRunOneIteration(GrayscaleGeodesicErodeImageFilter self, bool RunOneIteration)"""
        return _SimpleITK.GrayscaleGeodesicErodeImageFilter_SetRunOneIteration(self, RunOneIteration)

    def RunOneIterationOn(self):
        r"""RunOneIterationOn(GrayscaleGeodesicErodeImageFilter self)"""
        return _SimpleITK.GrayscaleGeodesicErodeImageFilter_RunOneIterationOn(self)

    def RunOneIterationOff(self):
        r"""RunOneIterationOff(GrayscaleGeodesicErodeImageFilter self)"""
        return _SimpleITK.GrayscaleGeodesicErodeImageFilter_RunOneIterationOff(self)

    def GetRunOneIteration(self):
        r"""GetRunOneIteration(GrayscaleGeodesicErodeImageFilter self) -> bool"""
        return _SimpleITK.GrayscaleGeodesicErodeImageFilter_GetRunOneIteration(self)

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(GrayscaleGeodesicErodeImageFilter self, bool FullyConnected)"""
        return _SimpleITK.GrayscaleGeodesicErodeImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(GrayscaleGeodesicErodeImageFilter self)"""
        return _SimpleITK.GrayscaleGeodesicErodeImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(GrayscaleGeodesicErodeImageFilter self)"""
        return _SimpleITK.GrayscaleGeodesicErodeImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(GrayscaleGeodesicErodeImageFilter self) -> bool"""
        return _SimpleITK.GrayscaleGeodesicErodeImageFilter_GetFullyConnected(self)

    def GetName(self):
        r"""GetName(GrayscaleGeodesicErodeImageFilter self) -> std::string"""
        return _SimpleITK.GrayscaleGeodesicErodeImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(GrayscaleGeodesicErodeImageFilter self) -> std::string"""
        return _SimpleITK.GrayscaleGeodesicErodeImageFilter___str__(self)

    def Execute(self, image1, image2):
        r"""Execute(GrayscaleGeodesicErodeImageFilter self, Image image1, Image image2) -> Image"""
        return _SimpleITK.GrayscaleGeodesicErodeImageFilter_Execute(self, image1, image2)

# Register GrayscaleGeodesicErodeImageFilter in _SimpleITK:
_SimpleITK.GrayscaleGeodesicErodeImageFilter_swigregister(GrayscaleGeodesicErodeImageFilter)

def GrayscaleGeodesicErode(image1, image2, runOneIteration=False, fullyConnected=False):
    r"""GrayscaleGeodesicErode(Image image1, Image image2, bool runOneIteration=False, bool fullyConnected=False) -> Image"""
    return _SimpleITK.GrayscaleGeodesicErode(image1, image2, runOneIteration, fullyConnected)
class GrayscaleGrindPeakImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::GrayscaleGrindPeakImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_GrayscaleGrindPeakImageFilter

    def __init__(self):
        r"""__init__(GrayscaleGrindPeakImageFilter self) -> GrayscaleGrindPeakImageFilter"""
        _SimpleITK.GrayscaleGrindPeakImageFilter_swiginit(self, _SimpleITK.new_GrayscaleGrindPeakImageFilter())

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(GrayscaleGrindPeakImageFilter self, bool FullyConnected)"""
        return _SimpleITK.GrayscaleGrindPeakImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(GrayscaleGrindPeakImageFilter self)"""
        return _SimpleITK.GrayscaleGrindPeakImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(GrayscaleGrindPeakImageFilter self)"""
        return _SimpleITK.GrayscaleGrindPeakImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(GrayscaleGrindPeakImageFilter self) -> bool"""
        return _SimpleITK.GrayscaleGrindPeakImageFilter_GetFullyConnected(self)

    def GetName(self):
        r"""GetName(GrayscaleGrindPeakImageFilter self) -> std::string"""
        return _SimpleITK.GrayscaleGrindPeakImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(GrayscaleGrindPeakImageFilter self) -> std::string"""
        return _SimpleITK.GrayscaleGrindPeakImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(GrayscaleGrindPeakImageFilter self, Image image1) -> Image"""
        return _SimpleITK.GrayscaleGrindPeakImageFilter_Execute(self, image1)

# Register GrayscaleGrindPeakImageFilter in _SimpleITK:
_SimpleITK.GrayscaleGrindPeakImageFilter_swigregister(GrayscaleGrindPeakImageFilter)

def GrayscaleGrindPeak(image1, fullyConnected=False):
    r"""GrayscaleGrindPeak(Image image1, bool fullyConnected=False) -> Image"""
    return _SimpleITK.GrayscaleGrindPeak(image1, fullyConnected)
class GrayscaleMorphologicalClosingImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::GrayscaleMorphologicalClosingImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_GrayscaleMorphologicalClosingImageFilter

    def __init__(self):
        r"""__init__(GrayscaleMorphologicalClosingImageFilter self) -> GrayscaleMorphologicalClosingImageFilter"""
        _SimpleITK.GrayscaleMorphologicalClosingImageFilter_swiginit(self, _SimpleITK.new_GrayscaleMorphologicalClosingImageFilter())

    def SetKernelRadius(self, *args):
        r"""
        SetKernelRadius(GrayscaleMorphologicalClosingImageFilter self, VectorUInt32 KernelRadius)
        SetKernelRadius(GrayscaleMorphologicalClosingImageFilter self, unsigned int value)
        """
        return _SimpleITK.GrayscaleMorphologicalClosingImageFilter_SetKernelRadius(self, *args)

    def GetKernelRadius(self):
        r"""GetKernelRadius(GrayscaleMorphologicalClosingImageFilter self) -> VectorUInt32"""
        return _SimpleITK.GrayscaleMorphologicalClosingImageFilter_GetKernelRadius(self)

    def SetKernelType(self, KernelType):
        r"""SetKernelType(GrayscaleMorphologicalClosingImageFilter self, slicer_itk::simple::KernelEnum KernelType)"""
        return _SimpleITK.GrayscaleMorphologicalClosingImageFilter_SetKernelType(self, KernelType)

    def GetKernelType(self):
        r"""GetKernelType(GrayscaleMorphologicalClosingImageFilter self) -> slicer_itk::simple::KernelEnum"""
        return _SimpleITK.GrayscaleMorphologicalClosingImageFilter_GetKernelType(self)

    def SetSafeBorder(self, SafeBorder):
        r"""SetSafeBorder(GrayscaleMorphologicalClosingImageFilter self, bool SafeBorder)"""
        return _SimpleITK.GrayscaleMorphologicalClosingImageFilter_SetSafeBorder(self, SafeBorder)

    def SafeBorderOn(self):
        r"""SafeBorderOn(GrayscaleMorphologicalClosingImageFilter self)"""
        return _SimpleITK.GrayscaleMorphologicalClosingImageFilter_SafeBorderOn(self)

    def SafeBorderOff(self):
        r"""SafeBorderOff(GrayscaleMorphologicalClosingImageFilter self)"""
        return _SimpleITK.GrayscaleMorphologicalClosingImageFilter_SafeBorderOff(self)

    def GetSafeBorder(self):
        r"""GetSafeBorder(GrayscaleMorphologicalClosingImageFilter self) -> bool"""
        return _SimpleITK.GrayscaleMorphologicalClosingImageFilter_GetSafeBorder(self)

    def GetName(self):
        r"""GetName(GrayscaleMorphologicalClosingImageFilter self) -> std::string"""
        return _SimpleITK.GrayscaleMorphologicalClosingImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(GrayscaleMorphologicalClosingImageFilter self) -> std::string"""
        return _SimpleITK.GrayscaleMorphologicalClosingImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(GrayscaleMorphologicalClosingImageFilter self, Image image1) -> Image"""
        return _SimpleITK.GrayscaleMorphologicalClosingImageFilter_Execute(self, image1)

# Register GrayscaleMorphologicalClosingImageFilter in _SimpleITK:
_SimpleITK.GrayscaleMorphologicalClosingImageFilter_swigregister(GrayscaleMorphologicalClosingImageFilter)

def GrayscaleMorphologicalClosing(*args, **kwargs):
    r"""GrayscaleMorphologicalClosing(Image image1, VectorUInt32 kernelRadius=std::vector< uint32_t >(3, 1), slicer_itk::simple::KernelEnum kernelType=sitkBall, bool safeBorder=True) -> Image"""
    return _SimpleITK.GrayscaleMorphologicalClosing(*args, **kwargs)
class GrayscaleMorphologicalOpeningImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::GrayscaleMorphologicalOpeningImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_GrayscaleMorphologicalOpeningImageFilter

    def __init__(self):
        r"""__init__(GrayscaleMorphologicalOpeningImageFilter self) -> GrayscaleMorphologicalOpeningImageFilter"""
        _SimpleITK.GrayscaleMorphologicalOpeningImageFilter_swiginit(self, _SimpleITK.new_GrayscaleMorphologicalOpeningImageFilter())

    def SetKernelRadius(self, *args):
        r"""
        SetKernelRadius(GrayscaleMorphologicalOpeningImageFilter self, VectorUInt32 KernelRadius)
        SetKernelRadius(GrayscaleMorphologicalOpeningImageFilter self, unsigned int value)
        """
        return _SimpleITK.GrayscaleMorphologicalOpeningImageFilter_SetKernelRadius(self, *args)

    def GetKernelRadius(self):
        r"""GetKernelRadius(GrayscaleMorphologicalOpeningImageFilter self) -> VectorUInt32"""
        return _SimpleITK.GrayscaleMorphologicalOpeningImageFilter_GetKernelRadius(self)

    def SetKernelType(self, KernelType):
        r"""SetKernelType(GrayscaleMorphologicalOpeningImageFilter self, slicer_itk::simple::KernelEnum KernelType)"""
        return _SimpleITK.GrayscaleMorphologicalOpeningImageFilter_SetKernelType(self, KernelType)

    def GetKernelType(self):
        r"""GetKernelType(GrayscaleMorphologicalOpeningImageFilter self) -> slicer_itk::simple::KernelEnum"""
        return _SimpleITK.GrayscaleMorphologicalOpeningImageFilter_GetKernelType(self)

    def SetSafeBorder(self, SafeBorder):
        r"""SetSafeBorder(GrayscaleMorphologicalOpeningImageFilter self, bool SafeBorder)"""
        return _SimpleITK.GrayscaleMorphologicalOpeningImageFilter_SetSafeBorder(self, SafeBorder)

    def SafeBorderOn(self):
        r"""SafeBorderOn(GrayscaleMorphologicalOpeningImageFilter self)"""
        return _SimpleITK.GrayscaleMorphologicalOpeningImageFilter_SafeBorderOn(self)

    def SafeBorderOff(self):
        r"""SafeBorderOff(GrayscaleMorphologicalOpeningImageFilter self)"""
        return _SimpleITK.GrayscaleMorphologicalOpeningImageFilter_SafeBorderOff(self)

    def GetSafeBorder(self):
        r"""GetSafeBorder(GrayscaleMorphologicalOpeningImageFilter self) -> bool"""
        return _SimpleITK.GrayscaleMorphologicalOpeningImageFilter_GetSafeBorder(self)

    def GetName(self):
        r"""GetName(GrayscaleMorphologicalOpeningImageFilter self) -> std::string"""
        return _SimpleITK.GrayscaleMorphologicalOpeningImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(GrayscaleMorphologicalOpeningImageFilter self) -> std::string"""
        return _SimpleITK.GrayscaleMorphologicalOpeningImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(GrayscaleMorphologicalOpeningImageFilter self, Image image1) -> Image"""
        return _SimpleITK.GrayscaleMorphologicalOpeningImageFilter_Execute(self, image1)

# Register GrayscaleMorphologicalOpeningImageFilter in _SimpleITK:
_SimpleITK.GrayscaleMorphologicalOpeningImageFilter_swigregister(GrayscaleMorphologicalOpeningImageFilter)

def GrayscaleMorphologicalOpening(*args, **kwargs):
    r"""GrayscaleMorphologicalOpening(Image image1, VectorUInt32 kernelRadius=std::vector< uint32_t >(3, 1), slicer_itk::simple::KernelEnum kernelType=sitkBall, bool safeBorder=True) -> Image"""
    return _SimpleITK.GrayscaleMorphologicalOpening(*args, **kwargs)
class GreaterEqualImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::GreaterEqualImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_GreaterEqualImageFilter

    def __init__(self):
        r"""__init__(GreaterEqualImageFilter self) -> GreaterEqualImageFilter"""
        _SimpleITK.GreaterEqualImageFilter_swiginit(self, _SimpleITK.new_GreaterEqualImageFilter())

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(GreaterEqualImageFilter self, uint8_t BackgroundValue)"""
        return _SimpleITK.GreaterEqualImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(GreaterEqualImageFilter self) -> uint8_t"""
        return _SimpleITK.GreaterEqualImageFilter_GetBackgroundValue(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(GreaterEqualImageFilter self, uint8_t ForegroundValue)"""
        return _SimpleITK.GreaterEqualImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(GreaterEqualImageFilter self) -> uint8_t"""
        return _SimpleITK.GreaterEqualImageFilter_GetForegroundValue(self)

    def GetName(self):
        r"""GetName(GreaterEqualImageFilter self) -> std::string"""
        return _SimpleITK.GreaterEqualImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(GreaterEqualImageFilter self) -> std::string"""
        return _SimpleITK.GreaterEqualImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(GreaterEqualImageFilter self, Image image1, Image image2) -> Image
        Execute(GreaterEqualImageFilter self, Image image1, double constant) -> Image
        Execute(GreaterEqualImageFilter self, double constant, Image image2) -> Image
        Execute(GreaterEqualImageFilter self, Image image1, double constant, uint8_t backgroundValue, uint8_t foregroundValue) -> Image
        Execute(GreaterEqualImageFilter self, double constant, Image image2, uint8_t backgroundValue, uint8_t foregroundValue) -> Image
        """
        return _SimpleITK.GreaterEqualImageFilter_Execute(self, *args)

# Register GreaterEqualImageFilter in _SimpleITK:
_SimpleITK.GreaterEqualImageFilter_swigregister(GreaterEqualImageFilter)

def GreaterEqual(*args):
    r"""
    GreaterEqual(Image image1, Image image2, uint8_t backgroundValue=0, uint8_t foregroundValue=1) -> Image
    GreaterEqual(Image image1, double constant, uint8_t backgroundValue=0, uint8_t foregroundValue=1) -> Image
    GreaterEqual(double constant, Image image2, uint8_t backgroundValue=0, uint8_t foregroundValue=1) -> Image
    """
    return _SimpleITK.GreaterEqual(*args)
class GreaterImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::GreaterImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_GreaterImageFilter

    def __init__(self):
        r"""__init__(GreaterImageFilter self) -> GreaterImageFilter"""
        _SimpleITK.GreaterImageFilter_swiginit(self, _SimpleITK.new_GreaterImageFilter())

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(GreaterImageFilter self, uint8_t BackgroundValue)"""
        return _SimpleITK.GreaterImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(GreaterImageFilter self) -> uint8_t"""
        return _SimpleITK.GreaterImageFilter_GetBackgroundValue(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(GreaterImageFilter self, uint8_t ForegroundValue)"""
        return _SimpleITK.GreaterImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(GreaterImageFilter self) -> uint8_t"""
        return _SimpleITK.GreaterImageFilter_GetForegroundValue(self)

    def GetName(self):
        r"""GetName(GreaterImageFilter self) -> std::string"""
        return _SimpleITK.GreaterImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(GreaterImageFilter self) -> std::string"""
        return _SimpleITK.GreaterImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(GreaterImageFilter self, Image image1, Image image2) -> Image
        Execute(GreaterImageFilter self, Image image1, double constant) -> Image
        Execute(GreaterImageFilter self, double constant, Image image2) -> Image
        Execute(GreaterImageFilter self, Image image1, double constant, uint8_t backgroundValue, uint8_t foregroundValue) -> Image
        Execute(GreaterImageFilter self, double constant, Image image2, uint8_t backgroundValue, uint8_t foregroundValue) -> Image
        """
        return _SimpleITK.GreaterImageFilter_Execute(self, *args)

# Register GreaterImageFilter in _SimpleITK:
_SimpleITK.GreaterImageFilter_swigregister(GreaterImageFilter)

def Greater(*args):
    r"""
    Greater(Image image1, Image image2, uint8_t backgroundValue=0, uint8_t foregroundValue=1) -> Image
    Greater(Image image1, double constant, uint8_t backgroundValue=0, uint8_t foregroundValue=1) -> Image
    Greater(double constant, Image image2, uint8_t backgroundValue=0, uint8_t foregroundValue=1) -> Image
    """
    return _SimpleITK.Greater(*args)
class GridImageSource(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::GridImageSource class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_GridImageSource

    def __init__(self):
        r"""__init__(GridImageSource self) -> GridImageSource"""
        _SimpleITK.GridImageSource_swiginit(self, _SimpleITK.new_GridImageSource())

    def SetOutputPixelType(self, OutputPixelType):
        r"""SetOutputPixelType(GridImageSource self, slicer_itk::simple::PixelIDValueEnum OutputPixelType)"""
        return _SimpleITK.GridImageSource_SetOutputPixelType(self, OutputPixelType)

    def GetOutputPixelType(self):
        r"""GetOutputPixelType(GridImageSource self) -> slicer_itk::simple::PixelIDValueEnum"""
        return _SimpleITK.GridImageSource_GetOutputPixelType(self)

    def SetSize(self, Size):
        r"""SetSize(GridImageSource self, VectorUInt32 Size)"""
        return _SimpleITK.GridImageSource_SetSize(self, Size)

    def GetSize(self):
        r"""GetSize(GridImageSource self) -> VectorUInt32"""
        return _SimpleITK.GridImageSource_GetSize(self)

    def SetSigma(self, *args):
        r"""
        SetSigma(GridImageSource self, VectorDouble Sigma)
        SetSigma(GridImageSource self, double value)
        """
        return _SimpleITK.GridImageSource_SetSigma(self, *args)

    def GetSigma(self):
        r"""GetSigma(GridImageSource self) -> VectorDouble"""
        return _SimpleITK.GridImageSource_GetSigma(self)

    def SetGridSpacing(self, GridSpacing):
        r"""SetGridSpacing(GridImageSource self, VectorDouble GridSpacing)"""
        return _SimpleITK.GridImageSource_SetGridSpacing(self, GridSpacing)

    def GetGridSpacing(self):
        r"""GetGridSpacing(GridImageSource self) -> VectorDouble"""
        return _SimpleITK.GridImageSource_GetGridSpacing(self)

    def SetGridOffset(self, GridOffset):
        r"""SetGridOffset(GridImageSource self, VectorDouble GridOffset)"""
        return _SimpleITK.GridImageSource_SetGridOffset(self, GridOffset)

    def GetGridOffset(self):
        r"""GetGridOffset(GridImageSource self) -> VectorDouble"""
        return _SimpleITK.GridImageSource_GetGridOffset(self)

    def SetScale(self, Scale):
        r"""SetScale(GridImageSource self, double Scale)"""
        return _SimpleITK.GridImageSource_SetScale(self, Scale)

    def GetScale(self):
        r"""GetScale(GridImageSource self) -> double"""
        return _SimpleITK.GridImageSource_GetScale(self)

    def SetOrigin(self, Origin):
        r"""SetOrigin(GridImageSource self, VectorDouble Origin)"""
        return _SimpleITK.GridImageSource_SetOrigin(self, Origin)

    def GetOrigin(self):
        r"""GetOrigin(GridImageSource self) -> VectorDouble"""
        return _SimpleITK.GridImageSource_GetOrigin(self)

    def SetSpacing(self, Spacing):
        r"""SetSpacing(GridImageSource self, VectorDouble Spacing)"""
        return _SimpleITK.GridImageSource_SetSpacing(self, Spacing)

    def GetSpacing(self):
        r"""GetSpacing(GridImageSource self) -> VectorDouble"""
        return _SimpleITK.GridImageSource_GetSpacing(self)

    def SetDirection(self, Direction):
        r"""SetDirection(GridImageSource self, VectorDouble Direction)"""
        return _SimpleITK.GridImageSource_SetDirection(self, Direction)

    def GetDirection(self):
        r"""GetDirection(GridImageSource self) -> VectorDouble"""
        return _SimpleITK.GridImageSource_GetDirection(self)

    def SetWhichDimensions(self, WhichDimensions):
        r"""SetWhichDimensions(GridImageSource self, VectorBool WhichDimensions)"""
        return _SimpleITK.GridImageSource_SetWhichDimensions(self, WhichDimensions)

    def GetWhichDimensions(self):
        r"""GetWhichDimensions(GridImageSource self) -> VectorBool"""
        return _SimpleITK.GridImageSource_GetWhichDimensions(self)

    def GetName(self):
        r"""GetName(GridImageSource self) -> std::string"""
        return _SimpleITK.GridImageSource_GetName(self)

    def __str__(self):
        r"""__str__(GridImageSource self) -> std::string"""
        return _SimpleITK.GridImageSource___str__(self)

    def Execute(self):
        r"""Execute(GridImageSource self) -> Image"""
        return _SimpleITK.GridImageSource_Execute(self)

# Register GridImageSource in _SimpleITK:
_SimpleITK.GridImageSource_swigregister(GridImageSource)

def GridSource(*args, **kwargs):
    r"""GridSource(slicer_itk::simple::PixelIDValueEnum outputPixelType=sitkFloat32, VectorUInt32 size=std::vector< unsigned int >(3, 64), VectorDouble sigma=std::vector< double >(3, 0.5), VectorDouble gridSpacing=std::vector< double >(3, 4.0), VectorDouble gridOffset=std::vector< double >(3, 0.0), double scale=255.0, VectorDouble origin=std::vector< double >(3, 0.0), VectorDouble spacing=std::vector< double >(3, 1.0), VectorDouble direction=std::vector< double >(), VectorBool whichDimensions=std::vector< bool >(3, true)) -> Image"""
    return _SimpleITK.GridSource(*args, **kwargs)
class HConcaveImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::HConcaveImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_HConcaveImageFilter

    def __init__(self):
        r"""__init__(HConcaveImageFilter self) -> HConcaveImageFilter"""
        _SimpleITK.HConcaveImageFilter_swiginit(self, _SimpleITK.new_HConcaveImageFilter())

    def SetHeight(self, Height):
        r"""SetHeight(HConcaveImageFilter self, double Height)"""
        return _SimpleITK.HConcaveImageFilter_SetHeight(self, Height)

    def GetHeight(self):
        r"""GetHeight(HConcaveImageFilter self) -> double"""
        return _SimpleITK.HConcaveImageFilter_GetHeight(self)

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(HConcaveImageFilter self, bool FullyConnected)"""
        return _SimpleITK.HConcaveImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(HConcaveImageFilter self)"""
        return _SimpleITK.HConcaveImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(HConcaveImageFilter self)"""
        return _SimpleITK.HConcaveImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(HConcaveImageFilter self) -> bool"""
        return _SimpleITK.HConcaveImageFilter_GetFullyConnected(self)

    def GetName(self):
        r"""GetName(HConcaveImageFilter self) -> std::string"""
        return _SimpleITK.HConcaveImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(HConcaveImageFilter self) -> std::string"""
        return _SimpleITK.HConcaveImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(HConcaveImageFilter self, Image image1) -> Image"""
        return _SimpleITK.HConcaveImageFilter_Execute(self, image1)

# Register HConcaveImageFilter in _SimpleITK:
_SimpleITK.HConcaveImageFilter_swigregister(HConcaveImageFilter)

def HConcave(image1, height=2.0, fullyConnected=False):
    r"""HConcave(Image image1, double height=2.0, bool fullyConnected=False) -> Image"""
    return _SimpleITK.HConcave(image1, height, fullyConnected)
class HConvexImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::HConvexImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_HConvexImageFilter

    def __init__(self):
        r"""__init__(HConvexImageFilter self) -> HConvexImageFilter"""
        _SimpleITK.HConvexImageFilter_swiginit(self, _SimpleITK.new_HConvexImageFilter())

    def SetHeight(self, Height):
        r"""SetHeight(HConvexImageFilter self, double Height)"""
        return _SimpleITK.HConvexImageFilter_SetHeight(self, Height)

    def GetHeight(self):
        r"""GetHeight(HConvexImageFilter self) -> double"""
        return _SimpleITK.HConvexImageFilter_GetHeight(self)

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(HConvexImageFilter self, bool FullyConnected)"""
        return _SimpleITK.HConvexImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(HConvexImageFilter self)"""
        return _SimpleITK.HConvexImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(HConvexImageFilter self)"""
        return _SimpleITK.HConvexImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(HConvexImageFilter self) -> bool"""
        return _SimpleITK.HConvexImageFilter_GetFullyConnected(self)

    def GetName(self):
        r"""GetName(HConvexImageFilter self) -> std::string"""
        return _SimpleITK.HConvexImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(HConvexImageFilter self) -> std::string"""
        return _SimpleITK.HConvexImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(HConvexImageFilter self, Image image1) -> Image"""
        return _SimpleITK.HConvexImageFilter_Execute(self, image1)

# Register HConvexImageFilter in _SimpleITK:
_SimpleITK.HConvexImageFilter_swigregister(HConvexImageFilter)

def HConvex(image1, height=2.0, fullyConnected=False):
    r"""HConvex(Image image1, double height=2.0, bool fullyConnected=False) -> Image"""
    return _SimpleITK.HConvex(image1, height, fullyConnected)
class HMaximaImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::HMaximaImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_HMaximaImageFilter

    def __init__(self):
        r"""__init__(HMaximaImageFilter self) -> HMaximaImageFilter"""
        _SimpleITK.HMaximaImageFilter_swiginit(self, _SimpleITK.new_HMaximaImageFilter())

    def SetHeight(self, Height):
        r"""SetHeight(HMaximaImageFilter self, double Height)"""
        return _SimpleITK.HMaximaImageFilter_SetHeight(self, Height)

    def GetHeight(self):
        r"""GetHeight(HMaximaImageFilter self) -> double"""
        return _SimpleITK.HMaximaImageFilter_GetHeight(self)

    def GetName(self):
        r"""GetName(HMaximaImageFilter self) -> std::string"""
        return _SimpleITK.HMaximaImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(HMaximaImageFilter self) -> std::string"""
        return _SimpleITK.HMaximaImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(HMaximaImageFilter self, Image image1) -> Image"""
        return _SimpleITK.HMaximaImageFilter_Execute(self, image1)

# Register HMaximaImageFilter in _SimpleITK:
_SimpleITK.HMaximaImageFilter_swigregister(HMaximaImageFilter)

def HMaxima(image1, height=2.0):
    r"""HMaxima(Image image1, double height=2.0) -> Image"""
    return _SimpleITK.HMaxima(image1, height)
class HMinimaImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::HMinimaImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_HMinimaImageFilter

    def __init__(self):
        r"""__init__(HMinimaImageFilter self) -> HMinimaImageFilter"""
        _SimpleITK.HMinimaImageFilter_swiginit(self, _SimpleITK.new_HMinimaImageFilter())

    def SetHeight(self, Height):
        r"""SetHeight(HMinimaImageFilter self, double Height)"""
        return _SimpleITK.HMinimaImageFilter_SetHeight(self, Height)

    def GetHeight(self):
        r"""GetHeight(HMinimaImageFilter self) -> double"""
        return _SimpleITK.HMinimaImageFilter_GetHeight(self)

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(HMinimaImageFilter self, bool FullyConnected)"""
        return _SimpleITK.HMinimaImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(HMinimaImageFilter self)"""
        return _SimpleITK.HMinimaImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(HMinimaImageFilter self)"""
        return _SimpleITK.HMinimaImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(HMinimaImageFilter self) -> bool"""
        return _SimpleITK.HMinimaImageFilter_GetFullyConnected(self)

    def GetName(self):
        r"""GetName(HMinimaImageFilter self) -> std::string"""
        return _SimpleITK.HMinimaImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(HMinimaImageFilter self) -> std::string"""
        return _SimpleITK.HMinimaImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(HMinimaImageFilter self, Image image1) -> Image"""
        return _SimpleITK.HMinimaImageFilter_Execute(self, image1)

# Register HMinimaImageFilter in _SimpleITK:
_SimpleITK.HMinimaImageFilter_swigregister(HMinimaImageFilter)

def HMinima(image1, height=2.0, fullyConnected=False):
    r"""HMinima(Image image1, double height=2.0, bool fullyConnected=False) -> Image"""
    return _SimpleITK.HMinima(image1, height, fullyConnected)
class HalfHermitianToRealInverseFFTImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::HalfHermitianToRealInverseFFTImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_HalfHermitianToRealInverseFFTImageFilter

    def __init__(self):
        r"""__init__(HalfHermitianToRealInverseFFTImageFilter self) -> HalfHermitianToRealInverseFFTImageFilter"""
        _SimpleITK.HalfHermitianToRealInverseFFTImageFilter_swiginit(self, _SimpleITK.new_HalfHermitianToRealInverseFFTImageFilter())

    def SetActualXDimensionIsOdd(self, ActualXDimensionIsOdd):
        r"""SetActualXDimensionIsOdd(HalfHermitianToRealInverseFFTImageFilter self, bool ActualXDimensionIsOdd)"""
        return _SimpleITK.HalfHermitianToRealInverseFFTImageFilter_SetActualXDimensionIsOdd(self, ActualXDimensionIsOdd)

    def ActualXDimensionIsOddOn(self):
        r"""ActualXDimensionIsOddOn(HalfHermitianToRealInverseFFTImageFilter self)"""
        return _SimpleITK.HalfHermitianToRealInverseFFTImageFilter_ActualXDimensionIsOddOn(self)

    def ActualXDimensionIsOddOff(self):
        r"""ActualXDimensionIsOddOff(HalfHermitianToRealInverseFFTImageFilter self)"""
        return _SimpleITK.HalfHermitianToRealInverseFFTImageFilter_ActualXDimensionIsOddOff(self)

    def GetActualXDimensionIsOdd(self):
        r"""GetActualXDimensionIsOdd(HalfHermitianToRealInverseFFTImageFilter self) -> bool"""
        return _SimpleITK.HalfHermitianToRealInverseFFTImageFilter_GetActualXDimensionIsOdd(self)

    def GetName(self):
        r"""GetName(HalfHermitianToRealInverseFFTImageFilter self) -> std::string"""
        return _SimpleITK.HalfHermitianToRealInverseFFTImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(HalfHermitianToRealInverseFFTImageFilter self) -> std::string"""
        return _SimpleITK.HalfHermitianToRealInverseFFTImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(HalfHermitianToRealInverseFFTImageFilter self, Image image1) -> Image"""
        return _SimpleITK.HalfHermitianToRealInverseFFTImageFilter_Execute(self, image1)

# Register HalfHermitianToRealInverseFFTImageFilter in _SimpleITK:
_SimpleITK.HalfHermitianToRealInverseFFTImageFilter_swigregister(HalfHermitianToRealInverseFFTImageFilter)

def HalfHermitianToRealInverseFFT(image1, actualXDimensionIsOdd=False):
    r"""HalfHermitianToRealInverseFFT(Image image1, bool actualXDimensionIsOdd=False) -> Image"""
    return _SimpleITK.HalfHermitianToRealInverseFFT(image1, actualXDimensionIsOdd)
class HausdorffDistanceImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::HausdorffDistanceImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_HausdorffDistanceImageFilter

    def __init__(self):
        r"""__init__(HausdorffDistanceImageFilter self) -> HausdorffDistanceImageFilter"""
        _SimpleITK.HausdorffDistanceImageFilter_swiginit(self, _SimpleITK.new_HausdorffDistanceImageFilter())

    def GetHausdorffDistance(self):
        r"""GetHausdorffDistance(HausdorffDistanceImageFilter self) -> double"""
        return _SimpleITK.HausdorffDistanceImageFilter_GetHausdorffDistance(self)

    def GetAverageHausdorffDistance(self):
        r"""GetAverageHausdorffDistance(HausdorffDistanceImageFilter self) -> double"""
        return _SimpleITK.HausdorffDistanceImageFilter_GetAverageHausdorffDistance(self)

    def GetName(self):
        r"""GetName(HausdorffDistanceImageFilter self) -> std::string"""
        return _SimpleITK.HausdorffDistanceImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(HausdorffDistanceImageFilter self) -> std::string"""
        return _SimpleITK.HausdorffDistanceImageFilter___str__(self)

    def Execute(self, image1, image2):
        r"""Execute(HausdorffDistanceImageFilter self, Image image1, Image image2)"""
        return _SimpleITK.HausdorffDistanceImageFilter_Execute(self, image1, image2)

# Register HausdorffDistanceImageFilter in _SimpleITK:
_SimpleITK.HausdorffDistanceImageFilter_swigregister(HausdorffDistanceImageFilter)
class HistogramMatchingImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::HistogramMatchingImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_HistogramMatchingImageFilter

    def __init__(self):
        r"""__init__(HistogramMatchingImageFilter self) -> HistogramMatchingImageFilter"""
        _SimpleITK.HistogramMatchingImageFilter_swiginit(self, _SimpleITK.new_HistogramMatchingImageFilter())

    def SetNumberOfHistogramLevels(self, NumberOfHistogramLevels):
        r"""SetNumberOfHistogramLevels(HistogramMatchingImageFilter self, uint32_t NumberOfHistogramLevels)"""
        return _SimpleITK.HistogramMatchingImageFilter_SetNumberOfHistogramLevels(self, NumberOfHistogramLevels)

    def GetNumberOfHistogramLevels(self):
        r"""GetNumberOfHistogramLevels(HistogramMatchingImageFilter self) -> uint32_t"""
        return _SimpleITK.HistogramMatchingImageFilter_GetNumberOfHistogramLevels(self)

    def SetNumberOfMatchPoints(self, NumberOfMatchPoints):
        r"""SetNumberOfMatchPoints(HistogramMatchingImageFilter self, uint32_t NumberOfMatchPoints)"""
        return _SimpleITK.HistogramMatchingImageFilter_SetNumberOfMatchPoints(self, NumberOfMatchPoints)

    def GetNumberOfMatchPoints(self):
        r"""GetNumberOfMatchPoints(HistogramMatchingImageFilter self) -> uint32_t"""
        return _SimpleITK.HistogramMatchingImageFilter_GetNumberOfMatchPoints(self)

    def SetThresholdAtMeanIntensity(self, ThresholdAtMeanIntensity):
        r"""SetThresholdAtMeanIntensity(HistogramMatchingImageFilter self, bool ThresholdAtMeanIntensity)"""
        return _SimpleITK.HistogramMatchingImageFilter_SetThresholdAtMeanIntensity(self, ThresholdAtMeanIntensity)

    def ThresholdAtMeanIntensityOn(self):
        r"""ThresholdAtMeanIntensityOn(HistogramMatchingImageFilter self)"""
        return _SimpleITK.HistogramMatchingImageFilter_ThresholdAtMeanIntensityOn(self)

    def ThresholdAtMeanIntensityOff(self):
        r"""ThresholdAtMeanIntensityOff(HistogramMatchingImageFilter self)"""
        return _SimpleITK.HistogramMatchingImageFilter_ThresholdAtMeanIntensityOff(self)

    def GetThresholdAtMeanIntensity(self):
        r"""GetThresholdAtMeanIntensity(HistogramMatchingImageFilter self) -> bool"""
        return _SimpleITK.HistogramMatchingImageFilter_GetThresholdAtMeanIntensity(self)

    def GetName(self):
        r"""GetName(HistogramMatchingImageFilter self) -> std::string"""
        return _SimpleITK.HistogramMatchingImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(HistogramMatchingImageFilter self) -> std::string"""
        return _SimpleITK.HistogramMatchingImageFilter___str__(self)

    def Execute(self, image, referenceImage):
        r"""Execute(HistogramMatchingImageFilter self, Image image, Image referenceImage) -> Image"""
        return _SimpleITK.HistogramMatchingImageFilter_Execute(self, image, referenceImage)

# Register HistogramMatchingImageFilter in _SimpleITK:
_SimpleITK.HistogramMatchingImageFilter_swigregister(HistogramMatchingImageFilter)

def HistogramMatching(image, referenceImage, numberOfHistogramLevels=256, numberOfMatchPoints=1, thresholdAtMeanIntensity=True):
    r"""HistogramMatching(Image image, Image referenceImage, uint32_t numberOfHistogramLevels=256, uint32_t numberOfMatchPoints=1, bool thresholdAtMeanIntensity=True) -> Image"""
    return _SimpleITK.HistogramMatching(image, referenceImage, numberOfHistogramLevels, numberOfMatchPoints, thresholdAtMeanIntensity)
class HuangThresholdImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::HuangThresholdImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_HuangThresholdImageFilter

    def __init__(self):
        r"""__init__(HuangThresholdImageFilter self) -> HuangThresholdImageFilter"""
        _SimpleITK.HuangThresholdImageFilter_swiginit(self, _SimpleITK.new_HuangThresholdImageFilter())

    def SetInsideValue(self, InsideValue):
        r"""SetInsideValue(HuangThresholdImageFilter self, uint8_t InsideValue)"""
        return _SimpleITK.HuangThresholdImageFilter_SetInsideValue(self, InsideValue)

    def GetInsideValue(self):
        r"""GetInsideValue(HuangThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.HuangThresholdImageFilter_GetInsideValue(self)

    def SetOutsideValue(self, OutsideValue):
        r"""SetOutsideValue(HuangThresholdImageFilter self, uint8_t OutsideValue)"""
        return _SimpleITK.HuangThresholdImageFilter_SetOutsideValue(self, OutsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(HuangThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.HuangThresholdImageFilter_GetOutsideValue(self)

    def SetNumberOfHistogramBins(self, NumberOfHistogramBins):
        r"""SetNumberOfHistogramBins(HuangThresholdImageFilter self, uint32_t NumberOfHistogramBins)"""
        return _SimpleITK.HuangThresholdImageFilter_SetNumberOfHistogramBins(self, NumberOfHistogramBins)

    def GetNumberOfHistogramBins(self):
        r"""GetNumberOfHistogramBins(HuangThresholdImageFilter self) -> uint32_t"""
        return _SimpleITK.HuangThresholdImageFilter_GetNumberOfHistogramBins(self)

    def SetMaskOutput(self, MaskOutput):
        r"""SetMaskOutput(HuangThresholdImageFilter self, bool MaskOutput)"""
        return _SimpleITK.HuangThresholdImageFilter_SetMaskOutput(self, MaskOutput)

    def MaskOutputOn(self):
        r"""MaskOutputOn(HuangThresholdImageFilter self)"""
        return _SimpleITK.HuangThresholdImageFilter_MaskOutputOn(self)

    def MaskOutputOff(self):
        r"""MaskOutputOff(HuangThresholdImageFilter self)"""
        return _SimpleITK.HuangThresholdImageFilter_MaskOutputOff(self)

    def GetMaskOutput(self):
        r"""GetMaskOutput(HuangThresholdImageFilter self) -> bool"""
        return _SimpleITK.HuangThresholdImageFilter_GetMaskOutput(self)

    def SetMaskValue(self, MaskValue):
        r"""SetMaskValue(HuangThresholdImageFilter self, uint8_t MaskValue)"""
        return _SimpleITK.HuangThresholdImageFilter_SetMaskValue(self, MaskValue)

    def GetMaskValue(self):
        r"""GetMaskValue(HuangThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.HuangThresholdImageFilter_GetMaskValue(self)

    def GetThreshold(self):
        r"""GetThreshold(HuangThresholdImageFilter self) -> double"""
        return _SimpleITK.HuangThresholdImageFilter_GetThreshold(self)

    def GetName(self):
        r"""GetName(HuangThresholdImageFilter self) -> std::string"""
        return _SimpleITK.HuangThresholdImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(HuangThresholdImageFilter self) -> std::string"""
        return _SimpleITK.HuangThresholdImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(HuangThresholdImageFilter self, Image image, Image maskImage) -> Image
        Execute(HuangThresholdImageFilter self, Image image) -> Image
        """
        return _SimpleITK.HuangThresholdImageFilter_Execute(self, *args)

# Register HuangThresholdImageFilter in _SimpleITK:
_SimpleITK.HuangThresholdImageFilter_swigregister(HuangThresholdImageFilter)

def HuangThreshold(*args):
    r"""
    HuangThreshold(Image image, Image maskImage, uint8_t insideValue=1, uint8_t outsideValue=0, uint32_t numberOfHistogramBins=128, bool maskOutput=True, uint8_t maskValue=255) -> Image
    HuangThreshold(Image image, uint8_t insideValue=1, uint8_t outsideValue=0, uint32_t numberOfHistogramBins=128, bool maskOutput=True, uint8_t maskValue=255) -> Image
    """
    return _SimpleITK.HuangThreshold(*args)
class IntensityWindowingImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::IntensityWindowingImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_IntensityWindowingImageFilter

    def __init__(self):
        r"""__init__(IntensityWindowingImageFilter self) -> IntensityWindowingImageFilter"""
        _SimpleITK.IntensityWindowingImageFilter_swiginit(self, _SimpleITK.new_IntensityWindowingImageFilter())

    def SetWindowMinimum(self, WindowMinimum):
        r"""SetWindowMinimum(IntensityWindowingImageFilter self, double WindowMinimum)"""
        return _SimpleITK.IntensityWindowingImageFilter_SetWindowMinimum(self, WindowMinimum)

    def GetWindowMinimum(self):
        r"""GetWindowMinimum(IntensityWindowingImageFilter self) -> double"""
        return _SimpleITK.IntensityWindowingImageFilter_GetWindowMinimum(self)

    def SetWindowMaximum(self, WindowMaximum):
        r"""SetWindowMaximum(IntensityWindowingImageFilter self, double WindowMaximum)"""
        return _SimpleITK.IntensityWindowingImageFilter_SetWindowMaximum(self, WindowMaximum)

    def GetWindowMaximum(self):
        r"""GetWindowMaximum(IntensityWindowingImageFilter self) -> double"""
        return _SimpleITK.IntensityWindowingImageFilter_GetWindowMaximum(self)

    def SetOutputMinimum(self, OutputMinimum):
        r"""SetOutputMinimum(IntensityWindowingImageFilter self, double OutputMinimum)"""
        return _SimpleITK.IntensityWindowingImageFilter_SetOutputMinimum(self, OutputMinimum)

    def GetOutputMinimum(self):
        r"""GetOutputMinimum(IntensityWindowingImageFilter self) -> double"""
        return _SimpleITK.IntensityWindowingImageFilter_GetOutputMinimum(self)

    def SetOutputMaximum(self, OutputMaximum):
        r"""SetOutputMaximum(IntensityWindowingImageFilter self, double OutputMaximum)"""
        return _SimpleITK.IntensityWindowingImageFilter_SetOutputMaximum(self, OutputMaximum)

    def GetOutputMaximum(self):
        r"""GetOutputMaximum(IntensityWindowingImageFilter self) -> double"""
        return _SimpleITK.IntensityWindowingImageFilter_GetOutputMaximum(self)

    def GetName(self):
        r"""GetName(IntensityWindowingImageFilter self) -> std::string"""
        return _SimpleITK.IntensityWindowingImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(IntensityWindowingImageFilter self) -> std::string"""
        return _SimpleITK.IntensityWindowingImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(IntensityWindowingImageFilter self, Image image1) -> Image"""
        return _SimpleITK.IntensityWindowingImageFilter_Execute(self, image1)

# Register IntensityWindowingImageFilter in _SimpleITK:
_SimpleITK.IntensityWindowingImageFilter_swigregister(IntensityWindowingImageFilter)

def IntensityWindowing(image1, windowMinimum=0.0, windowMaximum=255.0, outputMinimum=0.0, outputMaximum=255.0):
    r"""IntensityWindowing(Image image1, double windowMinimum=0.0, double windowMaximum=255.0, double outputMinimum=0.0, double outputMaximum=255.0) -> Image"""
    return _SimpleITK.IntensityWindowing(image1, windowMinimum, windowMaximum, outputMinimum, outputMaximum)
class IntermodesThresholdImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::IntermodesThresholdImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_IntermodesThresholdImageFilter

    def __init__(self):
        r"""__init__(IntermodesThresholdImageFilter self) -> IntermodesThresholdImageFilter"""
        _SimpleITK.IntermodesThresholdImageFilter_swiginit(self, _SimpleITK.new_IntermodesThresholdImageFilter())

    def SetInsideValue(self, InsideValue):
        r"""SetInsideValue(IntermodesThresholdImageFilter self, uint8_t InsideValue)"""
        return _SimpleITK.IntermodesThresholdImageFilter_SetInsideValue(self, InsideValue)

    def GetInsideValue(self):
        r"""GetInsideValue(IntermodesThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.IntermodesThresholdImageFilter_GetInsideValue(self)

    def SetOutsideValue(self, OutsideValue):
        r"""SetOutsideValue(IntermodesThresholdImageFilter self, uint8_t OutsideValue)"""
        return _SimpleITK.IntermodesThresholdImageFilter_SetOutsideValue(self, OutsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(IntermodesThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.IntermodesThresholdImageFilter_GetOutsideValue(self)

    def SetNumberOfHistogramBins(self, NumberOfHistogramBins):
        r"""SetNumberOfHistogramBins(IntermodesThresholdImageFilter self, uint32_t NumberOfHistogramBins)"""
        return _SimpleITK.IntermodesThresholdImageFilter_SetNumberOfHistogramBins(self, NumberOfHistogramBins)

    def GetNumberOfHistogramBins(self):
        r"""GetNumberOfHistogramBins(IntermodesThresholdImageFilter self) -> uint32_t"""
        return _SimpleITK.IntermodesThresholdImageFilter_GetNumberOfHistogramBins(self)

    def SetMaskOutput(self, MaskOutput):
        r"""SetMaskOutput(IntermodesThresholdImageFilter self, bool MaskOutput)"""
        return _SimpleITK.IntermodesThresholdImageFilter_SetMaskOutput(self, MaskOutput)

    def MaskOutputOn(self):
        r"""MaskOutputOn(IntermodesThresholdImageFilter self)"""
        return _SimpleITK.IntermodesThresholdImageFilter_MaskOutputOn(self)

    def MaskOutputOff(self):
        r"""MaskOutputOff(IntermodesThresholdImageFilter self)"""
        return _SimpleITK.IntermodesThresholdImageFilter_MaskOutputOff(self)

    def GetMaskOutput(self):
        r"""GetMaskOutput(IntermodesThresholdImageFilter self) -> bool"""
        return _SimpleITK.IntermodesThresholdImageFilter_GetMaskOutput(self)

    def SetMaskValue(self, MaskValue):
        r"""SetMaskValue(IntermodesThresholdImageFilter self, uint8_t MaskValue)"""
        return _SimpleITK.IntermodesThresholdImageFilter_SetMaskValue(self, MaskValue)

    def GetMaskValue(self):
        r"""GetMaskValue(IntermodesThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.IntermodesThresholdImageFilter_GetMaskValue(self)

    def GetThreshold(self):
        r"""GetThreshold(IntermodesThresholdImageFilter self) -> double"""
        return _SimpleITK.IntermodesThresholdImageFilter_GetThreshold(self)

    def GetName(self):
        r"""GetName(IntermodesThresholdImageFilter self) -> std::string"""
        return _SimpleITK.IntermodesThresholdImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(IntermodesThresholdImageFilter self) -> std::string"""
        return _SimpleITK.IntermodesThresholdImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(IntermodesThresholdImageFilter self, Image image, Image maskImage) -> Image
        Execute(IntermodesThresholdImageFilter self, Image image) -> Image
        """
        return _SimpleITK.IntermodesThresholdImageFilter_Execute(self, *args)

# Register IntermodesThresholdImageFilter in _SimpleITK:
_SimpleITK.IntermodesThresholdImageFilter_swigregister(IntermodesThresholdImageFilter)

def IntermodesThreshold(*args):
    r"""
    IntermodesThreshold(Image image, Image maskImage, uint8_t insideValue=1, uint8_t outsideValue=0, uint32_t numberOfHistogramBins=256, bool maskOutput=True, uint8_t maskValue=255) -> Image
    IntermodesThreshold(Image image, uint8_t insideValue=1, uint8_t outsideValue=0, uint32_t numberOfHistogramBins=256, bool maskOutput=True, uint8_t maskValue=255) -> Image
    """
    return _SimpleITK.IntermodesThreshold(*args)
class InverseDeconvolutionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::InverseDeconvolutionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_InverseDeconvolutionImageFilter

    def __init__(self):
        r"""__init__(InverseDeconvolutionImageFilter self) -> InverseDeconvolutionImageFilter"""
        _SimpleITK.InverseDeconvolutionImageFilter_swiginit(self, _SimpleITK.new_InverseDeconvolutionImageFilter())

    def SetKernelZeroMagnitudeThreshold(self, KernelZeroMagnitudeThreshold):
        r"""SetKernelZeroMagnitudeThreshold(InverseDeconvolutionImageFilter self, double KernelZeroMagnitudeThreshold)"""
        return _SimpleITK.InverseDeconvolutionImageFilter_SetKernelZeroMagnitudeThreshold(self, KernelZeroMagnitudeThreshold)

    def GetKernelZeroMagnitudeThreshold(self):
        r"""GetKernelZeroMagnitudeThreshold(InverseDeconvolutionImageFilter self) -> double"""
        return _SimpleITK.InverseDeconvolutionImageFilter_GetKernelZeroMagnitudeThreshold(self)

    def SetNormalize(self, Normalize):
        r"""SetNormalize(InverseDeconvolutionImageFilter self, bool Normalize)"""
        return _SimpleITK.InverseDeconvolutionImageFilter_SetNormalize(self, Normalize)

    def NormalizeOn(self):
        r"""NormalizeOn(InverseDeconvolutionImageFilter self)"""
        return _SimpleITK.InverseDeconvolutionImageFilter_NormalizeOn(self)

    def NormalizeOff(self):
        r"""NormalizeOff(InverseDeconvolutionImageFilter self)"""
        return _SimpleITK.InverseDeconvolutionImageFilter_NormalizeOff(self)

    def GetNormalize(self):
        r"""GetNormalize(InverseDeconvolutionImageFilter self) -> bool"""
        return _SimpleITK.InverseDeconvolutionImageFilter_GetNormalize(self)
    ZERO_PAD = _SimpleITK.InverseDeconvolutionImageFilter_ZERO_PAD
    
    ZERO_FLUX_NEUMANN_PAD = _SimpleITK.InverseDeconvolutionImageFilter_ZERO_FLUX_NEUMANN_PAD
    
    PERIODIC_PAD = _SimpleITK.InverseDeconvolutionImageFilter_PERIODIC_PAD
    

    def SetBoundaryCondition(self, BoundaryCondition):
        r"""SetBoundaryCondition(InverseDeconvolutionImageFilter self, slicer_itk::simple::InverseDeconvolutionImageFilter::BoundaryConditionType BoundaryCondition)"""
        return _SimpleITK.InverseDeconvolutionImageFilter_SetBoundaryCondition(self, BoundaryCondition)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(InverseDeconvolutionImageFilter self) -> slicer_itk::simple::InverseDeconvolutionImageFilter::BoundaryConditionType"""
        return _SimpleITK.InverseDeconvolutionImageFilter_GetBoundaryCondition(self)
    SAME = _SimpleITK.InverseDeconvolutionImageFilter_SAME
    
    VALID = _SimpleITK.InverseDeconvolutionImageFilter_VALID
    

    def SetOutputRegionMode(self, OutputRegionMode):
        r"""SetOutputRegionMode(InverseDeconvolutionImageFilter self, slicer_itk::simple::InverseDeconvolutionImageFilter::OutputRegionModeType OutputRegionMode)"""
        return _SimpleITK.InverseDeconvolutionImageFilter_SetOutputRegionMode(self, OutputRegionMode)

    def GetOutputRegionMode(self):
        r"""GetOutputRegionMode(InverseDeconvolutionImageFilter self) -> slicer_itk::simple::InverseDeconvolutionImageFilter::OutputRegionModeType"""
        return _SimpleITK.InverseDeconvolutionImageFilter_GetOutputRegionMode(self)

    def GetName(self):
        r"""GetName(InverseDeconvolutionImageFilter self) -> std::string"""
        return _SimpleITK.InverseDeconvolutionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(InverseDeconvolutionImageFilter self) -> std::string"""
        return _SimpleITK.InverseDeconvolutionImageFilter___str__(self)

    def Execute(self, image1, image2):
        r"""Execute(InverseDeconvolutionImageFilter self, Image image1, Image image2) -> Image"""
        return _SimpleITK.InverseDeconvolutionImageFilter_Execute(self, image1, image2)

# Register InverseDeconvolutionImageFilter in _SimpleITK:
_SimpleITK.InverseDeconvolutionImageFilter_swigregister(InverseDeconvolutionImageFilter)

def InverseDeconvolution(*args, **kwargs):
    r"""InverseDeconvolution(Image image1, Image image2, double kernelZeroMagnitudeThreshold=1.0e-4, bool normalize=False, slicer_itk::simple::InverseDeconvolutionImageFilter::BoundaryConditionType boundaryCondition=ZERO_FLUX_NEUMANN_PAD, slicer_itk::simple::InverseDeconvolutionImageFilter::OutputRegionModeType outputRegionMode=SAME) -> Image"""
    return _SimpleITK.InverseDeconvolution(*args, **kwargs)
class InverseDisplacementFieldImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::InverseDisplacementFieldImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_InverseDisplacementFieldImageFilter

    def __init__(self):
        r"""__init__(InverseDisplacementFieldImageFilter self) -> InverseDisplacementFieldImageFilter"""
        _SimpleITK.InverseDisplacementFieldImageFilter_swiginit(self, _SimpleITK.new_InverseDisplacementFieldImageFilter())

    def SetSize(self, Size):
        r"""SetSize(InverseDisplacementFieldImageFilter self, VectorUInt32 Size)"""
        return _SimpleITK.InverseDisplacementFieldImageFilter_SetSize(self, Size)

    def GetSize(self):
        r"""GetSize(InverseDisplacementFieldImageFilter self) -> VectorUInt32"""
        return _SimpleITK.InverseDisplacementFieldImageFilter_GetSize(self)

    def SetOutputOrigin(self, OutputOrigin):
        r"""SetOutputOrigin(InverseDisplacementFieldImageFilter self, VectorDouble OutputOrigin)"""
        return _SimpleITK.InverseDisplacementFieldImageFilter_SetOutputOrigin(self, OutputOrigin)

    def GetOutputOrigin(self):
        r"""GetOutputOrigin(InverseDisplacementFieldImageFilter self) -> VectorDouble"""
        return _SimpleITK.InverseDisplacementFieldImageFilter_GetOutputOrigin(self)

    def SetOutputSpacing(self, OutputSpacing):
        r"""SetOutputSpacing(InverseDisplacementFieldImageFilter self, VectorDouble OutputSpacing)"""
        return _SimpleITK.InverseDisplacementFieldImageFilter_SetOutputSpacing(self, OutputSpacing)

    def GetOutputSpacing(self):
        r"""GetOutputSpacing(InverseDisplacementFieldImageFilter self) -> VectorDouble"""
        return _SimpleITK.InverseDisplacementFieldImageFilter_GetOutputSpacing(self)

    def SetSubsamplingFactor(self, SubsamplingFactor):
        r"""SetSubsamplingFactor(InverseDisplacementFieldImageFilter self, unsigned int SubsamplingFactor)"""
        return _SimpleITK.InverseDisplacementFieldImageFilter_SetSubsamplingFactor(self, SubsamplingFactor)

    def GetSubsamplingFactor(self):
        r"""GetSubsamplingFactor(InverseDisplacementFieldImageFilter self) -> unsigned int"""
        return _SimpleITK.InverseDisplacementFieldImageFilter_GetSubsamplingFactor(self)

    def GetName(self):
        r"""GetName(InverseDisplacementFieldImageFilter self) -> std::string"""
        return _SimpleITK.InverseDisplacementFieldImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(InverseDisplacementFieldImageFilter self) -> std::string"""
        return _SimpleITK.InverseDisplacementFieldImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(InverseDisplacementFieldImageFilter self, Image image1) -> Image"""
        return _SimpleITK.InverseDisplacementFieldImageFilter_Execute(self, image1)

    def SetReferenceImage(self, refImage):
        r"""SetReferenceImage(InverseDisplacementFieldImageFilter self, Image refImage)"""
        return _SimpleITK.InverseDisplacementFieldImageFilter_SetReferenceImage(self, refImage)

# Register InverseDisplacementFieldImageFilter in _SimpleITK:
_SimpleITK.InverseDisplacementFieldImageFilter_swigregister(InverseDisplacementFieldImageFilter)

def InverseDisplacementField(*args, **kwargs):
    r"""InverseDisplacementField(Image image1, VectorUInt32 size=std::vector< uint32_t >(3, 0), VectorDouble outputOrigin=std::vector< double >(3, 0.0), VectorDouble outputSpacing=std::vector< double >(3, 1.0), unsigned int subsamplingFactor=16) -> Image"""
    return _SimpleITK.InverseDisplacementField(*args, **kwargs)
class InverseFFTImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::InverseFFTImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_InverseFFTImageFilter

    def __init__(self):
        r"""__init__(InverseFFTImageFilter self) -> InverseFFTImageFilter"""
        _SimpleITK.InverseFFTImageFilter_swiginit(self, _SimpleITK.new_InverseFFTImageFilter())

    def GetName(self):
        r"""GetName(InverseFFTImageFilter self) -> std::string"""
        return _SimpleITK.InverseFFTImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(InverseFFTImageFilter self) -> std::string"""
        return _SimpleITK.InverseFFTImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(InverseFFTImageFilter self, Image image1) -> Image"""
        return _SimpleITK.InverseFFTImageFilter_Execute(self, image1)

# Register InverseFFTImageFilter in _SimpleITK:
_SimpleITK.InverseFFTImageFilter_swigregister(InverseFFTImageFilter)

def InverseFFT(image1):
    r"""InverseFFT(Image image1) -> Image"""
    return _SimpleITK.InverseFFT(image1)
class InvertDisplacementFieldImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::InvertDisplacementFieldImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_InvertDisplacementFieldImageFilter

    def __init__(self):
        r"""__init__(InvertDisplacementFieldImageFilter self) -> InvertDisplacementFieldImageFilter"""
        _SimpleITK.InvertDisplacementFieldImageFilter_swiginit(self, _SimpleITK.new_InvertDisplacementFieldImageFilter())

    def SetMaximumNumberOfIterations(self, MaximumNumberOfIterations):
        r"""SetMaximumNumberOfIterations(InvertDisplacementFieldImageFilter self, uint32_t MaximumNumberOfIterations)"""
        return _SimpleITK.InvertDisplacementFieldImageFilter_SetMaximumNumberOfIterations(self, MaximumNumberOfIterations)

    def GetMaximumNumberOfIterations(self):
        r"""GetMaximumNumberOfIterations(InvertDisplacementFieldImageFilter self) -> uint32_t"""
        return _SimpleITK.InvertDisplacementFieldImageFilter_GetMaximumNumberOfIterations(self)

    def SetMaxErrorToleranceThreshold(self, MaxErrorToleranceThreshold):
        r"""SetMaxErrorToleranceThreshold(InvertDisplacementFieldImageFilter self, double MaxErrorToleranceThreshold)"""
        return _SimpleITK.InvertDisplacementFieldImageFilter_SetMaxErrorToleranceThreshold(self, MaxErrorToleranceThreshold)

    def GetMaxErrorToleranceThreshold(self):
        r"""GetMaxErrorToleranceThreshold(InvertDisplacementFieldImageFilter self) -> double"""
        return _SimpleITK.InvertDisplacementFieldImageFilter_GetMaxErrorToleranceThreshold(self)

    def SetMeanErrorToleranceThreshold(self, MeanErrorToleranceThreshold):
        r"""SetMeanErrorToleranceThreshold(InvertDisplacementFieldImageFilter self, double MeanErrorToleranceThreshold)"""
        return _SimpleITK.InvertDisplacementFieldImageFilter_SetMeanErrorToleranceThreshold(self, MeanErrorToleranceThreshold)

    def GetMeanErrorToleranceThreshold(self):
        r"""GetMeanErrorToleranceThreshold(InvertDisplacementFieldImageFilter self) -> double"""
        return _SimpleITK.InvertDisplacementFieldImageFilter_GetMeanErrorToleranceThreshold(self)

    def SetEnforceBoundaryCondition(self, EnforceBoundaryCondition):
        r"""SetEnforceBoundaryCondition(InvertDisplacementFieldImageFilter self, bool EnforceBoundaryCondition)"""
        return _SimpleITK.InvertDisplacementFieldImageFilter_SetEnforceBoundaryCondition(self, EnforceBoundaryCondition)

    def EnforceBoundaryConditionOn(self):
        r"""EnforceBoundaryConditionOn(InvertDisplacementFieldImageFilter self)"""
        return _SimpleITK.InvertDisplacementFieldImageFilter_EnforceBoundaryConditionOn(self)

    def EnforceBoundaryConditionOff(self):
        r"""EnforceBoundaryConditionOff(InvertDisplacementFieldImageFilter self)"""
        return _SimpleITK.InvertDisplacementFieldImageFilter_EnforceBoundaryConditionOff(self)

    def GetEnforceBoundaryCondition(self):
        r"""GetEnforceBoundaryCondition(InvertDisplacementFieldImageFilter self) -> bool"""
        return _SimpleITK.InvertDisplacementFieldImageFilter_GetEnforceBoundaryCondition(self)

    def GetMaxErrorNorm(self):
        r"""GetMaxErrorNorm(InvertDisplacementFieldImageFilter self) -> double"""
        return _SimpleITK.InvertDisplacementFieldImageFilter_GetMaxErrorNorm(self)

    def GetMeanErrorNorm(self):
        r"""GetMeanErrorNorm(InvertDisplacementFieldImageFilter self) -> double"""
        return _SimpleITK.InvertDisplacementFieldImageFilter_GetMeanErrorNorm(self)

    def GetName(self):
        r"""GetName(InvertDisplacementFieldImageFilter self) -> std::string"""
        return _SimpleITK.InvertDisplacementFieldImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(InvertDisplacementFieldImageFilter self) -> std::string"""
        return _SimpleITK.InvertDisplacementFieldImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(InvertDisplacementFieldImageFilter self, Image image1) -> Image"""
        return _SimpleITK.InvertDisplacementFieldImageFilter_Execute(self, image1)

# Register InvertDisplacementFieldImageFilter in _SimpleITK:
_SimpleITK.InvertDisplacementFieldImageFilter_swigregister(InvertDisplacementFieldImageFilter)

def InvertDisplacementField(image1, maximumNumberOfIterations=10, maxErrorToleranceThreshold=0.1, meanErrorToleranceThreshold=0.001, enforceBoundaryCondition=True):
    r"""InvertDisplacementField(Image image1, uint32_t maximumNumberOfIterations=10, double maxErrorToleranceThreshold=0.1, double meanErrorToleranceThreshold=0.001, bool enforceBoundaryCondition=True) -> Image"""
    return _SimpleITK.InvertDisplacementField(image1, maximumNumberOfIterations, maxErrorToleranceThreshold, meanErrorToleranceThreshold, enforceBoundaryCondition)
class InvertIntensityImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::InvertIntensityImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_InvertIntensityImageFilter

    def __init__(self):
        r"""__init__(InvertIntensityImageFilter self) -> InvertIntensityImageFilter"""
        _SimpleITK.InvertIntensityImageFilter_swiginit(self, _SimpleITK.new_InvertIntensityImageFilter())

    def SetMaximum(self, Maximum):
        r"""SetMaximum(InvertIntensityImageFilter self, double Maximum)"""
        return _SimpleITK.InvertIntensityImageFilter_SetMaximum(self, Maximum)

    def GetMaximum(self):
        r"""GetMaximum(InvertIntensityImageFilter self) -> double"""
        return _SimpleITK.InvertIntensityImageFilter_GetMaximum(self)

    def GetName(self):
        r"""GetName(InvertIntensityImageFilter self) -> std::string"""
        return _SimpleITK.InvertIntensityImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(InvertIntensityImageFilter self) -> std::string"""
        return _SimpleITK.InvertIntensityImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(InvertIntensityImageFilter self, Image image1) -> Image"""
        return _SimpleITK.InvertIntensityImageFilter_Execute(self, image1)

# Register InvertIntensityImageFilter in _SimpleITK:
_SimpleITK.InvertIntensityImageFilter_swigregister(InvertIntensityImageFilter)

def InvertIntensity(image1, maximum=255):
    r"""InvertIntensity(Image image1, double maximum=255) -> Image"""
    return _SimpleITK.InvertIntensity(image1, maximum)
class IsoContourDistanceImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::IsoContourDistanceImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_IsoContourDistanceImageFilter

    def __init__(self):
        r"""__init__(IsoContourDistanceImageFilter self) -> IsoContourDistanceImageFilter"""
        _SimpleITK.IsoContourDistanceImageFilter_swiginit(self, _SimpleITK.new_IsoContourDistanceImageFilter())

    def SetLevelSetValue(self, LevelSetValue):
        r"""SetLevelSetValue(IsoContourDistanceImageFilter self, double LevelSetValue)"""
        return _SimpleITK.IsoContourDistanceImageFilter_SetLevelSetValue(self, LevelSetValue)

    def GetLevelSetValue(self):
        r"""GetLevelSetValue(IsoContourDistanceImageFilter self) -> double"""
        return _SimpleITK.IsoContourDistanceImageFilter_GetLevelSetValue(self)

    def SetFarValue(self, FarValue):
        r"""SetFarValue(IsoContourDistanceImageFilter self, double FarValue)"""
        return _SimpleITK.IsoContourDistanceImageFilter_SetFarValue(self, FarValue)

    def GetFarValue(self):
        r"""GetFarValue(IsoContourDistanceImageFilter self) -> double"""
        return _SimpleITK.IsoContourDistanceImageFilter_GetFarValue(self)

    def GetName(self):
        r"""GetName(IsoContourDistanceImageFilter self) -> std::string"""
        return _SimpleITK.IsoContourDistanceImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(IsoContourDistanceImageFilter self) -> std::string"""
        return _SimpleITK.IsoContourDistanceImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(IsoContourDistanceImageFilter self, Image image1) -> Image"""
        return _SimpleITK.IsoContourDistanceImageFilter_Execute(self, image1)

# Register IsoContourDistanceImageFilter in _SimpleITK:
_SimpleITK.IsoContourDistanceImageFilter_swigregister(IsoContourDistanceImageFilter)

def IsoContourDistance(image1, levelSetValue=0.0, farValue=10):
    r"""IsoContourDistance(Image image1, double levelSetValue=0.0, double farValue=10) -> Image"""
    return _SimpleITK.IsoContourDistance(image1, levelSetValue, farValue)
class IsoDataThresholdImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::IsoDataThresholdImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_IsoDataThresholdImageFilter

    def __init__(self):
        r"""__init__(IsoDataThresholdImageFilter self) -> IsoDataThresholdImageFilter"""
        _SimpleITK.IsoDataThresholdImageFilter_swiginit(self, _SimpleITK.new_IsoDataThresholdImageFilter())

    def SetInsideValue(self, InsideValue):
        r"""SetInsideValue(IsoDataThresholdImageFilter self, uint8_t InsideValue)"""
        return _SimpleITK.IsoDataThresholdImageFilter_SetInsideValue(self, InsideValue)

    def GetInsideValue(self):
        r"""GetInsideValue(IsoDataThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.IsoDataThresholdImageFilter_GetInsideValue(self)

    def SetOutsideValue(self, OutsideValue):
        r"""SetOutsideValue(IsoDataThresholdImageFilter self, uint8_t OutsideValue)"""
        return _SimpleITK.IsoDataThresholdImageFilter_SetOutsideValue(self, OutsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(IsoDataThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.IsoDataThresholdImageFilter_GetOutsideValue(self)

    def SetNumberOfHistogramBins(self, NumberOfHistogramBins):
        r"""SetNumberOfHistogramBins(IsoDataThresholdImageFilter self, uint32_t NumberOfHistogramBins)"""
        return _SimpleITK.IsoDataThresholdImageFilter_SetNumberOfHistogramBins(self, NumberOfHistogramBins)

    def GetNumberOfHistogramBins(self):
        r"""GetNumberOfHistogramBins(IsoDataThresholdImageFilter self) -> uint32_t"""
        return _SimpleITK.IsoDataThresholdImageFilter_GetNumberOfHistogramBins(self)

    def SetMaskOutput(self, MaskOutput):
        r"""SetMaskOutput(IsoDataThresholdImageFilter self, bool MaskOutput)"""
        return _SimpleITK.IsoDataThresholdImageFilter_SetMaskOutput(self, MaskOutput)

    def MaskOutputOn(self):
        r"""MaskOutputOn(IsoDataThresholdImageFilter self)"""
        return _SimpleITK.IsoDataThresholdImageFilter_MaskOutputOn(self)

    def MaskOutputOff(self):
        r"""MaskOutputOff(IsoDataThresholdImageFilter self)"""
        return _SimpleITK.IsoDataThresholdImageFilter_MaskOutputOff(self)

    def GetMaskOutput(self):
        r"""GetMaskOutput(IsoDataThresholdImageFilter self) -> bool"""
        return _SimpleITK.IsoDataThresholdImageFilter_GetMaskOutput(self)

    def SetMaskValue(self, MaskValue):
        r"""SetMaskValue(IsoDataThresholdImageFilter self, uint8_t MaskValue)"""
        return _SimpleITK.IsoDataThresholdImageFilter_SetMaskValue(self, MaskValue)

    def GetMaskValue(self):
        r"""GetMaskValue(IsoDataThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.IsoDataThresholdImageFilter_GetMaskValue(self)

    def GetThreshold(self):
        r"""GetThreshold(IsoDataThresholdImageFilter self) -> double"""
        return _SimpleITK.IsoDataThresholdImageFilter_GetThreshold(self)

    def GetName(self):
        r"""GetName(IsoDataThresholdImageFilter self) -> std::string"""
        return _SimpleITK.IsoDataThresholdImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(IsoDataThresholdImageFilter self) -> std::string"""
        return _SimpleITK.IsoDataThresholdImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(IsoDataThresholdImageFilter self, Image image, Image maskImage) -> Image
        Execute(IsoDataThresholdImageFilter self, Image image) -> Image
        """
        return _SimpleITK.IsoDataThresholdImageFilter_Execute(self, *args)

# Register IsoDataThresholdImageFilter in _SimpleITK:
_SimpleITK.IsoDataThresholdImageFilter_swigregister(IsoDataThresholdImageFilter)

def IsoDataThreshold(*args):
    r"""
    IsoDataThreshold(Image image, Image maskImage, uint8_t insideValue=1, uint8_t outsideValue=0, uint32_t numberOfHistogramBins=256, bool maskOutput=True, uint8_t maskValue=255) -> Image
    IsoDataThreshold(Image image, uint8_t insideValue=1, uint8_t outsideValue=0, uint32_t numberOfHistogramBins=256, bool maskOutput=True, uint8_t maskValue=255) -> Image
    """
    return _SimpleITK.IsoDataThreshold(*args)
class IsolatedConnectedImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::IsolatedConnectedImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_IsolatedConnectedImageFilter

    def __init__(self):
        r"""__init__(IsolatedConnectedImageFilter self) -> IsolatedConnectedImageFilter"""
        _SimpleITK.IsolatedConnectedImageFilter_swiginit(self, _SimpleITK.new_IsolatedConnectedImageFilter())

    def SetSeed1(self, Seed1):
        r"""SetSeed1(IsolatedConnectedImageFilter self, VectorUInt32 Seed1)"""
        return _SimpleITK.IsolatedConnectedImageFilter_SetSeed1(self, Seed1)

    def GetSeed1(self):
        r"""GetSeed1(IsolatedConnectedImageFilter self) -> VectorUInt32"""
        return _SimpleITK.IsolatedConnectedImageFilter_GetSeed1(self)

    def SetSeed2(self, Seed2):
        r"""SetSeed2(IsolatedConnectedImageFilter self, VectorUInt32 Seed2)"""
        return _SimpleITK.IsolatedConnectedImageFilter_SetSeed2(self, Seed2)

    def GetSeed2(self):
        r"""GetSeed2(IsolatedConnectedImageFilter self) -> VectorUInt32"""
        return _SimpleITK.IsolatedConnectedImageFilter_GetSeed2(self)

    def SetLower(self, Lower):
        r"""SetLower(IsolatedConnectedImageFilter self, double Lower)"""
        return _SimpleITK.IsolatedConnectedImageFilter_SetLower(self, Lower)

    def GetLower(self):
        r"""GetLower(IsolatedConnectedImageFilter self) -> double"""
        return _SimpleITK.IsolatedConnectedImageFilter_GetLower(self)

    def SetUpper(self, Upper):
        r"""SetUpper(IsolatedConnectedImageFilter self, double Upper)"""
        return _SimpleITK.IsolatedConnectedImageFilter_SetUpper(self, Upper)

    def GetUpper(self):
        r"""GetUpper(IsolatedConnectedImageFilter self) -> double"""
        return _SimpleITK.IsolatedConnectedImageFilter_GetUpper(self)

    def SetReplaceValue(self, ReplaceValue):
        r"""SetReplaceValue(IsolatedConnectedImageFilter self, uint8_t ReplaceValue)"""
        return _SimpleITK.IsolatedConnectedImageFilter_SetReplaceValue(self, ReplaceValue)

    def GetReplaceValue(self):
        r"""GetReplaceValue(IsolatedConnectedImageFilter self) -> uint8_t"""
        return _SimpleITK.IsolatedConnectedImageFilter_GetReplaceValue(self)

    def SetIsolatedValueTolerance(self, IsolatedValueTolerance):
        r"""SetIsolatedValueTolerance(IsolatedConnectedImageFilter self, double IsolatedValueTolerance)"""
        return _SimpleITK.IsolatedConnectedImageFilter_SetIsolatedValueTolerance(self, IsolatedValueTolerance)

    def GetIsolatedValueTolerance(self):
        r"""GetIsolatedValueTolerance(IsolatedConnectedImageFilter self) -> double"""
        return _SimpleITK.IsolatedConnectedImageFilter_GetIsolatedValueTolerance(self)

    def SetFindUpperThreshold(self, FindUpperThreshold):
        r"""SetFindUpperThreshold(IsolatedConnectedImageFilter self, bool FindUpperThreshold)"""
        return _SimpleITK.IsolatedConnectedImageFilter_SetFindUpperThreshold(self, FindUpperThreshold)

    def FindUpperThresholdOn(self):
        r"""FindUpperThresholdOn(IsolatedConnectedImageFilter self)"""
        return _SimpleITK.IsolatedConnectedImageFilter_FindUpperThresholdOn(self)

    def FindUpperThresholdOff(self):
        r"""FindUpperThresholdOff(IsolatedConnectedImageFilter self)"""
        return _SimpleITK.IsolatedConnectedImageFilter_FindUpperThresholdOff(self)

    def GetFindUpperThreshold(self):
        r"""GetFindUpperThreshold(IsolatedConnectedImageFilter self) -> bool"""
        return _SimpleITK.IsolatedConnectedImageFilter_GetFindUpperThreshold(self)

    def GetThresholdingFailed(self):
        r"""GetThresholdingFailed(IsolatedConnectedImageFilter self) -> bool"""
        return _SimpleITK.IsolatedConnectedImageFilter_GetThresholdingFailed(self)

    def GetIsolatedValue(self):
        r"""GetIsolatedValue(IsolatedConnectedImageFilter self) -> double"""
        return _SimpleITK.IsolatedConnectedImageFilter_GetIsolatedValue(self)

    def GetName(self):
        r"""GetName(IsolatedConnectedImageFilter self) -> std::string"""
        return _SimpleITK.IsolatedConnectedImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(IsolatedConnectedImageFilter self) -> std::string"""
        return _SimpleITK.IsolatedConnectedImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(IsolatedConnectedImageFilter self, Image image1) -> Image"""
        return _SimpleITK.IsolatedConnectedImageFilter_Execute(self, image1)

# Register IsolatedConnectedImageFilter in _SimpleITK:
_SimpleITK.IsolatedConnectedImageFilter_swigregister(IsolatedConnectedImageFilter)

def IsolatedConnected(*args, **kwargs):
    r"""IsolatedConnected(Image image1, VectorUInt32 seed1=std::vector< unsigned int >(3, 0), VectorUInt32 seed2=std::vector< unsigned int >(3, 0), double lower=0, double upper=1, uint8_t replaceValue=1, double isolatedValueTolerance=1.0, bool findUpperThreshold=True) -> Image"""
    return _SimpleITK.IsolatedConnected(*args, **kwargs)
class IsolatedWatershedImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::IsolatedWatershedImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_IsolatedWatershedImageFilter

    def __init__(self):
        r"""__init__(IsolatedWatershedImageFilter self) -> IsolatedWatershedImageFilter"""
        _SimpleITK.IsolatedWatershedImageFilter_swiginit(self, _SimpleITK.new_IsolatedWatershedImageFilter())

    def SetSeed1(self, Seed1):
        r"""SetSeed1(IsolatedWatershedImageFilter self, VectorUInt32 Seed1)"""
        return _SimpleITK.IsolatedWatershedImageFilter_SetSeed1(self, Seed1)

    def GetSeed1(self):
        r"""GetSeed1(IsolatedWatershedImageFilter self) -> VectorUInt32"""
        return _SimpleITK.IsolatedWatershedImageFilter_GetSeed1(self)

    def SetSeed2(self, Seed2):
        r"""SetSeed2(IsolatedWatershedImageFilter self, VectorUInt32 Seed2)"""
        return _SimpleITK.IsolatedWatershedImageFilter_SetSeed2(self, Seed2)

    def GetSeed2(self):
        r"""GetSeed2(IsolatedWatershedImageFilter self) -> VectorUInt32"""
        return _SimpleITK.IsolatedWatershedImageFilter_GetSeed2(self)

    def SetThreshold(self, Threshold):
        r"""SetThreshold(IsolatedWatershedImageFilter self, double Threshold)"""
        return _SimpleITK.IsolatedWatershedImageFilter_SetThreshold(self, Threshold)

    def GetThreshold(self):
        r"""GetThreshold(IsolatedWatershedImageFilter self) -> double"""
        return _SimpleITK.IsolatedWatershedImageFilter_GetThreshold(self)

    def SetUpperValueLimit(self, UpperValueLimit):
        r"""SetUpperValueLimit(IsolatedWatershedImageFilter self, double UpperValueLimit)"""
        return _SimpleITK.IsolatedWatershedImageFilter_SetUpperValueLimit(self, UpperValueLimit)

    def GetUpperValueLimit(self):
        r"""GetUpperValueLimit(IsolatedWatershedImageFilter self) -> double"""
        return _SimpleITK.IsolatedWatershedImageFilter_GetUpperValueLimit(self)

    def SetIsolatedValueTolerance(self, IsolatedValueTolerance):
        r"""SetIsolatedValueTolerance(IsolatedWatershedImageFilter self, double IsolatedValueTolerance)"""
        return _SimpleITK.IsolatedWatershedImageFilter_SetIsolatedValueTolerance(self, IsolatedValueTolerance)

    def GetIsolatedValueTolerance(self):
        r"""GetIsolatedValueTolerance(IsolatedWatershedImageFilter self) -> double"""
        return _SimpleITK.IsolatedWatershedImageFilter_GetIsolatedValueTolerance(self)

    def SetReplaceValue1(self, ReplaceValue1):
        r"""SetReplaceValue1(IsolatedWatershedImageFilter self, uint8_t ReplaceValue1)"""
        return _SimpleITK.IsolatedWatershedImageFilter_SetReplaceValue1(self, ReplaceValue1)

    def GetReplaceValue1(self):
        r"""GetReplaceValue1(IsolatedWatershedImageFilter self) -> uint8_t"""
        return _SimpleITK.IsolatedWatershedImageFilter_GetReplaceValue1(self)

    def SetReplaceValue2(self, ReplaceValue2):
        r"""SetReplaceValue2(IsolatedWatershedImageFilter self, uint8_t ReplaceValue2)"""
        return _SimpleITK.IsolatedWatershedImageFilter_SetReplaceValue2(self, ReplaceValue2)

    def GetReplaceValue2(self):
        r"""GetReplaceValue2(IsolatedWatershedImageFilter self) -> uint8_t"""
        return _SimpleITK.IsolatedWatershedImageFilter_GetReplaceValue2(self)

    def GetName(self):
        r"""GetName(IsolatedWatershedImageFilter self) -> std::string"""
        return _SimpleITK.IsolatedWatershedImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(IsolatedWatershedImageFilter self) -> std::string"""
        return _SimpleITK.IsolatedWatershedImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(IsolatedWatershedImageFilter self, Image image1) -> Image"""
        return _SimpleITK.IsolatedWatershedImageFilter_Execute(self, image1)

# Register IsolatedWatershedImageFilter in _SimpleITK:
_SimpleITK.IsolatedWatershedImageFilter_swigregister(IsolatedWatershedImageFilter)

def IsolatedWatershed(*args, **kwargs):
    r"""IsolatedWatershed(Image image1, VectorUInt32 seed1=std::vector< uint32_t >(3, 0), VectorUInt32 seed2=std::vector< uint32_t >(3, 0), double threshold=0.0, double upperValueLimit=1.0, double isolatedValueTolerance=0.001, uint8_t replaceValue1=1, uint8_t replaceValue2=2) -> Image"""
    return _SimpleITK.IsolatedWatershed(*args, **kwargs)
class IterativeInverseDisplacementFieldImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::IterativeInverseDisplacementFieldImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_IterativeInverseDisplacementFieldImageFilter

    def __init__(self):
        r"""__init__(IterativeInverseDisplacementFieldImageFilter self) -> IterativeInverseDisplacementFieldImageFilter"""
        _SimpleITK.IterativeInverseDisplacementFieldImageFilter_swiginit(self, _SimpleITK.new_IterativeInverseDisplacementFieldImageFilter())

    def SetNumberOfIterations(self, NumberOfIterations):
        r"""SetNumberOfIterations(IterativeInverseDisplacementFieldImageFilter self, uint32_t NumberOfIterations)"""
        return _SimpleITK.IterativeInverseDisplacementFieldImageFilter_SetNumberOfIterations(self, NumberOfIterations)

    def GetNumberOfIterations(self):
        r"""GetNumberOfIterations(IterativeInverseDisplacementFieldImageFilter self) -> uint32_t"""
        return _SimpleITK.IterativeInverseDisplacementFieldImageFilter_GetNumberOfIterations(self)

    def SetStopValue(self, StopValue):
        r"""SetStopValue(IterativeInverseDisplacementFieldImageFilter self, double StopValue)"""
        return _SimpleITK.IterativeInverseDisplacementFieldImageFilter_SetStopValue(self, StopValue)

    def GetStopValue(self):
        r"""GetStopValue(IterativeInverseDisplacementFieldImageFilter self) -> double"""
        return _SimpleITK.IterativeInverseDisplacementFieldImageFilter_GetStopValue(self)

    def GetName(self):
        r"""GetName(IterativeInverseDisplacementFieldImageFilter self) -> std::string"""
        return _SimpleITK.IterativeInverseDisplacementFieldImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(IterativeInverseDisplacementFieldImageFilter self) -> std::string"""
        return _SimpleITK.IterativeInverseDisplacementFieldImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(IterativeInverseDisplacementFieldImageFilter self, Image image1) -> Image"""
        return _SimpleITK.IterativeInverseDisplacementFieldImageFilter_Execute(self, image1)

# Register IterativeInverseDisplacementFieldImageFilter in _SimpleITK:
_SimpleITK.IterativeInverseDisplacementFieldImageFilter_swigregister(IterativeInverseDisplacementFieldImageFilter)

def IterativeInverseDisplacementField(image1, numberOfIterations=5, stopValue=0.0):
    r"""IterativeInverseDisplacementField(Image image1, uint32_t numberOfIterations=5, double stopValue=0.0) -> Image"""
    return _SimpleITK.IterativeInverseDisplacementField(image1, numberOfIterations, stopValue)
class JoinSeriesImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::JoinSeriesImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_JoinSeriesImageFilter

    def __init__(self):
        r"""__init__(JoinSeriesImageFilter self) -> JoinSeriesImageFilter"""
        _SimpleITK.JoinSeriesImageFilter_swiginit(self, _SimpleITK.new_JoinSeriesImageFilter())

    def SetOrigin(self, Origin):
        r"""SetOrigin(JoinSeriesImageFilter self, double Origin)"""
        return _SimpleITK.JoinSeriesImageFilter_SetOrigin(self, Origin)

    def GetOrigin(self):
        r"""GetOrigin(JoinSeriesImageFilter self) -> double"""
        return _SimpleITK.JoinSeriesImageFilter_GetOrigin(self)

    def SetSpacing(self, Spacing):
        r"""SetSpacing(JoinSeriesImageFilter self, double Spacing)"""
        return _SimpleITK.JoinSeriesImageFilter_SetSpacing(self, Spacing)

    def GetSpacing(self):
        r"""GetSpacing(JoinSeriesImageFilter self) -> double"""
        return _SimpleITK.JoinSeriesImageFilter_GetSpacing(self)

    def GetName(self):
        r"""GetName(JoinSeriesImageFilter self) -> std::string"""
        return _SimpleITK.JoinSeriesImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(JoinSeriesImageFilter self) -> std::string"""
        return _SimpleITK.JoinSeriesImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(JoinSeriesImageFilter self, VectorOfImage images) -> Image
        Execute(JoinSeriesImageFilter self, Image image1) -> Image
        Execute(JoinSeriesImageFilter self, Image image1, Image image2) -> Image
        Execute(JoinSeriesImageFilter self, Image image1, Image image2, Image image3) -> Image
        Execute(JoinSeriesImageFilter self, Image image1, Image image2, Image image3, Image image4) -> Image
        Execute(JoinSeriesImageFilter self, Image image1, Image image2, Image image3, Image image4, Image image5) -> Image
        """
        return _SimpleITK.JoinSeriesImageFilter_Execute(self, *args)

# Register JoinSeriesImageFilter in _SimpleITK:
_SimpleITK.JoinSeriesImageFilter_swigregister(JoinSeriesImageFilter)

def JoinSeries(*args):
    r"""
    JoinSeries(VectorOfImage images, double origin=0.0, double spacing=1.0) -> Image
    JoinSeries(Image image1, double origin=0.0, double spacing=1.0) -> Image
    JoinSeries(Image image1, Image image2, double origin=0.0, double spacing=1.0) -> Image
    JoinSeries(Image image1, Image image2, Image image3, double origin=0.0, double spacing=1.0) -> Image
    JoinSeries(Image image1, Image image2, Image image3, Image image4, double origin=0.0, double spacing=1.0) -> Image
    JoinSeries(Image image1, Image image2, Image image3, Image image4, Image image5, double origin=0.0, double spacing=1.0) -> Image
    """
    return _SimpleITK.JoinSeries(*args)
class KittlerIllingworthThresholdImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::KittlerIllingworthThresholdImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_KittlerIllingworthThresholdImageFilter

    def __init__(self):
        r"""__init__(KittlerIllingworthThresholdImageFilter self) -> KittlerIllingworthThresholdImageFilter"""
        _SimpleITK.KittlerIllingworthThresholdImageFilter_swiginit(self, _SimpleITK.new_KittlerIllingworthThresholdImageFilter())

    def SetInsideValue(self, InsideValue):
        r"""SetInsideValue(KittlerIllingworthThresholdImageFilter self, uint8_t InsideValue)"""
        return _SimpleITK.KittlerIllingworthThresholdImageFilter_SetInsideValue(self, InsideValue)

    def GetInsideValue(self):
        r"""GetInsideValue(KittlerIllingworthThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.KittlerIllingworthThresholdImageFilter_GetInsideValue(self)

    def SetOutsideValue(self, OutsideValue):
        r"""SetOutsideValue(KittlerIllingworthThresholdImageFilter self, uint8_t OutsideValue)"""
        return _SimpleITK.KittlerIllingworthThresholdImageFilter_SetOutsideValue(self, OutsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(KittlerIllingworthThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.KittlerIllingworthThresholdImageFilter_GetOutsideValue(self)

    def SetNumberOfHistogramBins(self, NumberOfHistogramBins):
        r"""SetNumberOfHistogramBins(KittlerIllingworthThresholdImageFilter self, uint32_t NumberOfHistogramBins)"""
        return _SimpleITK.KittlerIllingworthThresholdImageFilter_SetNumberOfHistogramBins(self, NumberOfHistogramBins)

    def GetNumberOfHistogramBins(self):
        r"""GetNumberOfHistogramBins(KittlerIllingworthThresholdImageFilter self) -> uint32_t"""
        return _SimpleITK.KittlerIllingworthThresholdImageFilter_GetNumberOfHistogramBins(self)

    def SetMaskOutput(self, MaskOutput):
        r"""SetMaskOutput(KittlerIllingworthThresholdImageFilter self, bool MaskOutput)"""
        return _SimpleITK.KittlerIllingworthThresholdImageFilter_SetMaskOutput(self, MaskOutput)

    def MaskOutputOn(self):
        r"""MaskOutputOn(KittlerIllingworthThresholdImageFilter self)"""
        return _SimpleITK.KittlerIllingworthThresholdImageFilter_MaskOutputOn(self)

    def MaskOutputOff(self):
        r"""MaskOutputOff(KittlerIllingworthThresholdImageFilter self)"""
        return _SimpleITK.KittlerIllingworthThresholdImageFilter_MaskOutputOff(self)

    def GetMaskOutput(self):
        r"""GetMaskOutput(KittlerIllingworthThresholdImageFilter self) -> bool"""
        return _SimpleITK.KittlerIllingworthThresholdImageFilter_GetMaskOutput(self)

    def SetMaskValue(self, MaskValue):
        r"""SetMaskValue(KittlerIllingworthThresholdImageFilter self, uint8_t MaskValue)"""
        return _SimpleITK.KittlerIllingworthThresholdImageFilter_SetMaskValue(self, MaskValue)

    def GetMaskValue(self):
        r"""GetMaskValue(KittlerIllingworthThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.KittlerIllingworthThresholdImageFilter_GetMaskValue(self)

    def GetThreshold(self):
        r"""GetThreshold(KittlerIllingworthThresholdImageFilter self) -> double"""
        return _SimpleITK.KittlerIllingworthThresholdImageFilter_GetThreshold(self)

    def GetName(self):
        r"""GetName(KittlerIllingworthThresholdImageFilter self) -> std::string"""
        return _SimpleITK.KittlerIllingworthThresholdImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(KittlerIllingworthThresholdImageFilter self) -> std::string"""
        return _SimpleITK.KittlerIllingworthThresholdImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(KittlerIllingworthThresholdImageFilter self, Image image, Image maskImage) -> Image
        Execute(KittlerIllingworthThresholdImageFilter self, Image image) -> Image
        """
        return _SimpleITK.KittlerIllingworthThresholdImageFilter_Execute(self, *args)

# Register KittlerIllingworthThresholdImageFilter in _SimpleITK:
_SimpleITK.KittlerIllingworthThresholdImageFilter_swigregister(KittlerIllingworthThresholdImageFilter)

def KittlerIllingworthThreshold(*args):
    r"""
    KittlerIllingworthThreshold(Image image, Image maskImage, uint8_t insideValue=1, uint8_t outsideValue=0, uint32_t numberOfHistogramBins=256, bool maskOutput=True, uint8_t maskValue=255) -> Image
    KittlerIllingworthThreshold(Image image, uint8_t insideValue=1, uint8_t outsideValue=0, uint32_t numberOfHistogramBins=256, bool maskOutput=True, uint8_t maskValue=255) -> Image
    """
    return _SimpleITK.KittlerIllingworthThreshold(*args)
class LabelContourImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::LabelContourImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_LabelContourImageFilter

    def __init__(self):
        r"""__init__(LabelContourImageFilter self) -> LabelContourImageFilter"""
        _SimpleITK.LabelContourImageFilter_swiginit(self, _SimpleITK.new_LabelContourImageFilter())

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(LabelContourImageFilter self, bool FullyConnected)"""
        return _SimpleITK.LabelContourImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(LabelContourImageFilter self)"""
        return _SimpleITK.LabelContourImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(LabelContourImageFilter self)"""
        return _SimpleITK.LabelContourImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(LabelContourImageFilter self) -> bool"""
        return _SimpleITK.LabelContourImageFilter_GetFullyConnected(self)

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(LabelContourImageFilter self, double BackgroundValue)"""
        return _SimpleITK.LabelContourImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(LabelContourImageFilter self) -> double"""
        return _SimpleITK.LabelContourImageFilter_GetBackgroundValue(self)

    def GetName(self):
        r"""GetName(LabelContourImageFilter self) -> std::string"""
        return _SimpleITK.LabelContourImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(LabelContourImageFilter self) -> std::string"""
        return _SimpleITK.LabelContourImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(LabelContourImageFilter self, Image image1) -> Image"""
        return _SimpleITK.LabelContourImageFilter_Execute(self, image1)

# Register LabelContourImageFilter in _SimpleITK:
_SimpleITK.LabelContourImageFilter_swigregister(LabelContourImageFilter)

def LabelContour(image1, fullyConnected=False, backgroundValue=0):
    r"""LabelContour(Image image1, bool fullyConnected=False, double backgroundValue=0) -> Image"""
    return _SimpleITK.LabelContour(image1, fullyConnected, backgroundValue)
class LabelImageToLabelMapFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::LabelImageToLabelMapFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_LabelImageToLabelMapFilter

    def __init__(self):
        r"""__init__(LabelImageToLabelMapFilter self) -> LabelImageToLabelMapFilter"""
        _SimpleITK.LabelImageToLabelMapFilter_swiginit(self, _SimpleITK.new_LabelImageToLabelMapFilter())

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(LabelImageToLabelMapFilter self, double BackgroundValue)"""
        return _SimpleITK.LabelImageToLabelMapFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(LabelImageToLabelMapFilter self) -> double"""
        return _SimpleITK.LabelImageToLabelMapFilter_GetBackgroundValue(self)

    def GetName(self):
        r"""GetName(LabelImageToLabelMapFilter self) -> std::string"""
        return _SimpleITK.LabelImageToLabelMapFilter_GetName(self)

    def __str__(self):
        r"""__str__(LabelImageToLabelMapFilter self) -> std::string"""
        return _SimpleITK.LabelImageToLabelMapFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(LabelImageToLabelMapFilter self, Image image1) -> Image"""
        return _SimpleITK.LabelImageToLabelMapFilter_Execute(self, image1)

# Register LabelImageToLabelMapFilter in _SimpleITK:
_SimpleITK.LabelImageToLabelMapFilter_swigregister(LabelImageToLabelMapFilter)

def LabelImageToLabelMap(image1, backgroundValue=0):
    r"""LabelImageToLabelMap(Image image1, double backgroundValue=0) -> Image"""
    return _SimpleITK.LabelImageToLabelMap(image1, backgroundValue)
class LabelIntensityStatisticsImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::LabelIntensityStatisticsImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_LabelIntensityStatisticsImageFilter

    def __init__(self):
        r"""__init__(LabelIntensityStatisticsImageFilter self) -> LabelIntensityStatisticsImageFilter"""
        _SimpleITK.LabelIntensityStatisticsImageFilter_swiginit(self, _SimpleITK.new_LabelIntensityStatisticsImageFilter())

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(LabelIntensityStatisticsImageFilter self, double BackgroundValue)"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(LabelIntensityStatisticsImageFilter self) -> double"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetBackgroundValue(self)

    def SetComputeFeretDiameter(self, ComputeFeretDiameter):
        r"""SetComputeFeretDiameter(LabelIntensityStatisticsImageFilter self, bool ComputeFeretDiameter)"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_SetComputeFeretDiameter(self, ComputeFeretDiameter)

    def ComputeFeretDiameterOn(self):
        r"""ComputeFeretDiameterOn(LabelIntensityStatisticsImageFilter self)"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_ComputeFeretDiameterOn(self)

    def ComputeFeretDiameterOff(self):
        r"""ComputeFeretDiameterOff(LabelIntensityStatisticsImageFilter self)"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_ComputeFeretDiameterOff(self)

    def GetComputeFeretDiameter(self):
        r"""GetComputeFeretDiameter(LabelIntensityStatisticsImageFilter self) -> bool"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetComputeFeretDiameter(self)

    def SetComputePerimeter(self, ComputePerimeter):
        r"""SetComputePerimeter(LabelIntensityStatisticsImageFilter self, bool ComputePerimeter)"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_SetComputePerimeter(self, ComputePerimeter)

    def ComputePerimeterOn(self):
        r"""ComputePerimeterOn(LabelIntensityStatisticsImageFilter self)"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_ComputePerimeterOn(self)

    def ComputePerimeterOff(self):
        r"""ComputePerimeterOff(LabelIntensityStatisticsImageFilter self)"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_ComputePerimeterOff(self)

    def GetComputePerimeter(self):
        r"""GetComputePerimeter(LabelIntensityStatisticsImageFilter self) -> bool"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetComputePerimeter(self)

    def SetNumberOfBins(self, NumberOfBins):
        r"""SetNumberOfBins(LabelIntensityStatisticsImageFilter self, uint32_t NumberOfBins)"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_SetNumberOfBins(self, NumberOfBins)

    def GetNumberOfBins(self):
        r"""GetNumberOfBins(LabelIntensityStatisticsImageFilter self) -> uint32_t"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetNumberOfBins(self)

    def GetBoundingBox(self, label):
        r"""GetBoundingBox(LabelIntensityStatisticsImageFilter self, int64_t label) -> VectorUInt32"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetBoundingBox(self, label)

    def GetRegion(self, label):
        r"""GetRegion(LabelIntensityStatisticsImageFilter self, int64_t label) -> VectorUInt32"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetRegion(self, label)

    def GetCentroid(self, label):
        r"""GetCentroid(LabelIntensityStatisticsImageFilter self, int64_t label) -> VectorDouble"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetCentroid(self, label)

    def GetElongation(self, label):
        r"""GetElongation(LabelIntensityStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetElongation(self, label)

    def GetEquivalentEllipsoidDiameter(self, label):
        r"""GetEquivalentEllipsoidDiameter(LabelIntensityStatisticsImageFilter self, int64_t label) -> VectorDouble"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetEquivalentEllipsoidDiameter(self, label)

    def GetEquivalentSphericalPerimeter(self, label):
        r"""GetEquivalentSphericalPerimeter(LabelIntensityStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetEquivalentSphericalPerimeter(self, label)

    def GetEquivalentSphericalRadius(self, label):
        r"""GetEquivalentSphericalRadius(LabelIntensityStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetEquivalentSphericalRadius(self, label)

    def GetFeretDiameter(self, label):
        r"""GetFeretDiameter(LabelIntensityStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetFeretDiameter(self, label)

    def GetFlatness(self, label):
        r"""GetFlatness(LabelIntensityStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetFlatness(self, label)

    def GetLabels(self):
        r"""GetLabels(LabelIntensityStatisticsImageFilter self) -> VectorInt64"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetLabels(self)

    def GetNumberOfPixels(self, label):
        r"""GetNumberOfPixels(LabelIntensityStatisticsImageFilter self, int64_t label) -> uint64_t"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetNumberOfPixels(self, label)

    def GetNumberOfPixelsOnBorder(self, label):
        r"""GetNumberOfPixelsOnBorder(LabelIntensityStatisticsImageFilter self, int64_t label) -> uint64_t"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetNumberOfPixelsOnBorder(self, label)

    def GetPerimeter(self, label):
        r"""GetPerimeter(LabelIntensityStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetPerimeter(self, label)

    def GetPerimeterOnBorder(self, label):
        r"""GetPerimeterOnBorder(LabelIntensityStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetPerimeterOnBorder(self, label)

    def GetPerimeterOnBorderRatio(self, label):
        r"""GetPerimeterOnBorderRatio(LabelIntensityStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetPerimeterOnBorderRatio(self, label)

    def GetPhysicalSize(self, label):
        r"""GetPhysicalSize(LabelIntensityStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetPhysicalSize(self, label)

    def GetPrincipalAxes(self, label):
        r"""GetPrincipalAxes(LabelIntensityStatisticsImageFilter self, int64_t label) -> VectorDouble"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetPrincipalAxes(self, label)

    def GetPrincipalMoments(self, label):
        r"""GetPrincipalMoments(LabelIntensityStatisticsImageFilter self, int64_t label) -> VectorDouble"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetPrincipalMoments(self, label)

    def GetRoundness(self, label):
        r"""GetRoundness(LabelIntensityStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetRoundness(self, label)

    def GetCenterOfGravity(self, label):
        r"""GetCenterOfGravity(LabelIntensityStatisticsImageFilter self, int64_t label) -> VectorDouble"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetCenterOfGravity(self, label)

    def GetKurtosis(self, label):
        r"""GetKurtosis(LabelIntensityStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetKurtosis(self, label)

    def GetMaximum(self, label):
        r"""GetMaximum(LabelIntensityStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetMaximum(self, label)

    def GetMaximumIndex(self, label):
        r"""GetMaximumIndex(LabelIntensityStatisticsImageFilter self, int64_t label) -> VectorUInt32"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetMaximumIndex(self, label)

    def GetMean(self, label):
        r"""GetMean(LabelIntensityStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetMean(self, label)

    def GetMedian(self, label):
        r"""GetMedian(LabelIntensityStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetMedian(self, label)

    def GetMinimum(self, label):
        r"""GetMinimum(LabelIntensityStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetMinimum(self, label)

    def GetMinimumIndex(self, label):
        r"""GetMinimumIndex(LabelIntensityStatisticsImageFilter self, int64_t label) -> VectorUInt32"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetMinimumIndex(self, label)

    def GetSkewness(self, label):
        r"""GetSkewness(LabelIntensityStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetSkewness(self, label)

    def GetStandardDeviation(self, label):
        r"""GetStandardDeviation(LabelIntensityStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetStandardDeviation(self, label)

    def GetSum(self, label):
        r"""GetSum(LabelIntensityStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetSum(self, label)

    def GetVariance(self, label):
        r"""GetVariance(LabelIntensityStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetVariance(self, label)

    def GetWeightedElongation(self, label):
        r"""GetWeightedElongation(LabelIntensityStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetWeightedElongation(self, label)

    def GetWeightedFlatness(self, label):
        r"""GetWeightedFlatness(LabelIntensityStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetWeightedFlatness(self, label)

    def GetWeightedPrincipalAxes(self, label):
        r"""GetWeightedPrincipalAxes(LabelIntensityStatisticsImageFilter self, int64_t label) -> VectorDouble"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetWeightedPrincipalAxes(self, label)

    def GetWeightedPrincipalMoments(self, label):
        r"""GetWeightedPrincipalMoments(LabelIntensityStatisticsImageFilter self, int64_t label) -> VectorDouble"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetWeightedPrincipalMoments(self, label)

    def GetName(self):
        r"""GetName(LabelIntensityStatisticsImageFilter self) -> std::string"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(LabelIntensityStatisticsImageFilter self) -> std::string"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter___str__(self)

    def Execute(self, image, featureImage):
        r"""Execute(LabelIntensityStatisticsImageFilter self, Image image, Image featureImage)"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_Execute(self, image, featureImage)

    def HasLabel(self, label):
        r"""HasLabel(LabelIntensityStatisticsImageFilter self, int64_t label) -> bool"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_HasLabel(self, label)

    def GetNumberOfLabels(self):
        r"""GetNumberOfLabels(LabelIntensityStatisticsImageFilter self) -> uint64_t"""
        return _SimpleITK.LabelIntensityStatisticsImageFilter_GetNumberOfLabels(self)

# Register LabelIntensityStatisticsImageFilter in _SimpleITK:
_SimpleITK.LabelIntensityStatisticsImageFilter_swigregister(LabelIntensityStatisticsImageFilter)
class LabelMapContourOverlayImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::LabelMapContourOverlayImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_LabelMapContourOverlayImageFilter

    def __init__(self):
        r"""__init__(LabelMapContourOverlayImageFilter self) -> LabelMapContourOverlayImageFilter"""
        _SimpleITK.LabelMapContourOverlayImageFilter_swiginit(self, _SimpleITK.new_LabelMapContourOverlayImageFilter())

    def SetOpacity(self, Opacity):
        r"""SetOpacity(LabelMapContourOverlayImageFilter self, double Opacity)"""
        return _SimpleITK.LabelMapContourOverlayImageFilter_SetOpacity(self, Opacity)

    def GetOpacity(self):
        r"""GetOpacity(LabelMapContourOverlayImageFilter self) -> double"""
        return _SimpleITK.LabelMapContourOverlayImageFilter_GetOpacity(self)

    def SetDilationRadius(self, *args):
        r"""
        SetDilationRadius(LabelMapContourOverlayImageFilter self, VectorUInt32 DilationRadius)
        SetDilationRadius(LabelMapContourOverlayImageFilter self, unsigned int value)
        """
        return _SimpleITK.LabelMapContourOverlayImageFilter_SetDilationRadius(self, *args)

    def GetDilationRadius(self):
        r"""GetDilationRadius(LabelMapContourOverlayImageFilter self) -> VectorUInt32"""
        return _SimpleITK.LabelMapContourOverlayImageFilter_GetDilationRadius(self)

    def SetContourThickness(self, ContourThickness):
        r"""SetContourThickness(LabelMapContourOverlayImageFilter self, VectorUInt32 ContourThickness)"""
        return _SimpleITK.LabelMapContourOverlayImageFilter_SetContourThickness(self, ContourThickness)

    def GetContourThickness(self):
        r"""GetContourThickness(LabelMapContourOverlayImageFilter self) -> VectorUInt32"""
        return _SimpleITK.LabelMapContourOverlayImageFilter_GetContourThickness(self)

    def SetSliceDimension(self, SliceDimension):
        r"""SetSliceDimension(LabelMapContourOverlayImageFilter self, unsigned int SliceDimension)"""
        return _SimpleITK.LabelMapContourOverlayImageFilter_SetSliceDimension(self, SliceDimension)

    def GetSliceDimension(self):
        r"""GetSliceDimension(LabelMapContourOverlayImageFilter self) -> unsigned int"""
        return _SimpleITK.LabelMapContourOverlayImageFilter_GetSliceDimension(self)
    PLAIN = _SimpleITK.LabelMapContourOverlayImageFilter_PLAIN
    
    CONTOUR = _SimpleITK.LabelMapContourOverlayImageFilter_CONTOUR
    
    SLICE_CONTOUR = _SimpleITK.LabelMapContourOverlayImageFilter_SLICE_CONTOUR
    

    def SetContourType(self, ContourType):
        r"""SetContourType(LabelMapContourOverlayImageFilter self, slicer_itk::simple::LabelMapContourOverlayImageFilter::ContourTypeType ContourType)"""
        return _SimpleITK.LabelMapContourOverlayImageFilter_SetContourType(self, ContourType)

    def GetContourType(self):
        r"""GetContourType(LabelMapContourOverlayImageFilter self) -> slicer_itk::simple::LabelMapContourOverlayImageFilter::ContourTypeType"""
        return _SimpleITK.LabelMapContourOverlayImageFilter_GetContourType(self)
    HIGH_LABEL_ON_TOP = _SimpleITK.LabelMapContourOverlayImageFilter_HIGH_LABEL_ON_TOP
    
    LOW_LABEL_ON_TOP = _SimpleITK.LabelMapContourOverlayImageFilter_LOW_LABEL_ON_TOP
    

    def SetPriority(self, Priority):
        r"""SetPriority(LabelMapContourOverlayImageFilter self, slicer_itk::simple::LabelMapContourOverlayImageFilter::PriorityType Priority)"""
        return _SimpleITK.LabelMapContourOverlayImageFilter_SetPriority(self, Priority)

    def GetPriority(self):
        r"""GetPriority(LabelMapContourOverlayImageFilter self) -> slicer_itk::simple::LabelMapContourOverlayImageFilter::PriorityType"""
        return _SimpleITK.LabelMapContourOverlayImageFilter_GetPriority(self)

    def SetColormap(self, Colormap):
        r"""SetColormap(LabelMapContourOverlayImageFilter self, VectorUInt8 Colormap)"""
        return _SimpleITK.LabelMapContourOverlayImageFilter_SetColormap(self, Colormap)

    def GetColormap(self):
        r"""GetColormap(LabelMapContourOverlayImageFilter self) -> VectorUInt8"""
        return _SimpleITK.LabelMapContourOverlayImageFilter_GetColormap(self)

    def GetName(self):
        r"""GetName(LabelMapContourOverlayImageFilter self) -> std::string"""
        return _SimpleITK.LabelMapContourOverlayImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(LabelMapContourOverlayImageFilter self) -> std::string"""
        return _SimpleITK.LabelMapContourOverlayImageFilter___str__(self)

    def Execute(self, labelMapImage, featureImage):
        r"""Execute(LabelMapContourOverlayImageFilter self, Image labelMapImage, Image featureImage) -> Image"""
        return _SimpleITK.LabelMapContourOverlayImageFilter_Execute(self, labelMapImage, featureImage)

# Register LabelMapContourOverlayImageFilter in _SimpleITK:
_SimpleITK.LabelMapContourOverlayImageFilter_swigregister(LabelMapContourOverlayImageFilter)

def LabelMapContourOverlay(*args, **kwargs):
    r"""LabelMapContourOverlay(Image labelMapImage, Image featureImage, double opacity=0.5, VectorUInt32 dilationRadius=std::vector< unsigned int >(3, 1), VectorUInt32 contourThickness=std::vector< unsigned int >(3, 1), unsigned int sliceDimension=0, slicer_itk::simple::LabelMapContourOverlayImageFilter::ContourTypeType contourType=CONTOUR, slicer_itk::simple::LabelMapContourOverlayImageFilter::PriorityType priority=HIGH_LABEL_ON_TOP, VectorUInt8 colormap=std::vector< uint8_t >()) -> Image"""
    return _SimpleITK.LabelMapContourOverlay(*args, **kwargs)
class LabelMapMaskImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::LabelMapMaskImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_LabelMapMaskImageFilter

    def __init__(self):
        r"""__init__(LabelMapMaskImageFilter self) -> LabelMapMaskImageFilter"""
        _SimpleITK.LabelMapMaskImageFilter_swiginit(self, _SimpleITK.new_LabelMapMaskImageFilter())

    def SetLabel(self, Label):
        r"""SetLabel(LabelMapMaskImageFilter self, uint64_t Label)"""
        return _SimpleITK.LabelMapMaskImageFilter_SetLabel(self, Label)

    def GetLabel(self):
        r"""GetLabel(LabelMapMaskImageFilter self) -> uint64_t"""
        return _SimpleITK.LabelMapMaskImageFilter_GetLabel(self)

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(LabelMapMaskImageFilter self, double BackgroundValue)"""
        return _SimpleITK.LabelMapMaskImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(LabelMapMaskImageFilter self) -> double"""
        return _SimpleITK.LabelMapMaskImageFilter_GetBackgroundValue(self)

    def SetNegated(self, Negated):
        r"""SetNegated(LabelMapMaskImageFilter self, bool Negated)"""
        return _SimpleITK.LabelMapMaskImageFilter_SetNegated(self, Negated)

    def NegatedOn(self):
        r"""NegatedOn(LabelMapMaskImageFilter self)"""
        return _SimpleITK.LabelMapMaskImageFilter_NegatedOn(self)

    def NegatedOff(self):
        r"""NegatedOff(LabelMapMaskImageFilter self)"""
        return _SimpleITK.LabelMapMaskImageFilter_NegatedOff(self)

    def GetNegated(self):
        r"""GetNegated(LabelMapMaskImageFilter self) -> bool"""
        return _SimpleITK.LabelMapMaskImageFilter_GetNegated(self)

    def SetCrop(self, Crop):
        r"""SetCrop(LabelMapMaskImageFilter self, bool Crop)"""
        return _SimpleITK.LabelMapMaskImageFilter_SetCrop(self, Crop)

    def CropOn(self):
        r"""CropOn(LabelMapMaskImageFilter self)"""
        return _SimpleITK.LabelMapMaskImageFilter_CropOn(self)

    def CropOff(self):
        r"""CropOff(LabelMapMaskImageFilter self)"""
        return _SimpleITK.LabelMapMaskImageFilter_CropOff(self)

    def GetCrop(self):
        r"""GetCrop(LabelMapMaskImageFilter self) -> bool"""
        return _SimpleITK.LabelMapMaskImageFilter_GetCrop(self)

    def SetCropBorder(self, *args):
        r"""
        SetCropBorder(LabelMapMaskImageFilter self, VectorUInt32 CropBorder)
        SetCropBorder(LabelMapMaskImageFilter self, unsigned int value)
        """
        return _SimpleITK.LabelMapMaskImageFilter_SetCropBorder(self, *args)

    def GetCropBorder(self):
        r"""GetCropBorder(LabelMapMaskImageFilter self) -> VectorUInt32"""
        return _SimpleITK.LabelMapMaskImageFilter_GetCropBorder(self)

    def GetName(self):
        r"""GetName(LabelMapMaskImageFilter self) -> std::string"""
        return _SimpleITK.LabelMapMaskImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(LabelMapMaskImageFilter self) -> std::string"""
        return _SimpleITK.LabelMapMaskImageFilter___str__(self)

    def Execute(self, labelMapImage, featureImage):
        r"""Execute(LabelMapMaskImageFilter self, Image labelMapImage, Image featureImage) -> Image"""
        return _SimpleITK.LabelMapMaskImageFilter_Execute(self, labelMapImage, featureImage)

# Register LabelMapMaskImageFilter in _SimpleITK:
_SimpleITK.LabelMapMaskImageFilter_swigregister(LabelMapMaskImageFilter)

def LabelMapMask(*args, **kwargs):
    r"""LabelMapMask(Image labelMapImage, Image featureImage, uint64_t label=1, double backgroundValue=0, bool negated=False, bool crop=False, VectorUInt32 cropBorder=std::vector< unsigned int >(3, 0)) -> Image"""
    return _SimpleITK.LabelMapMask(*args, **kwargs)
class LabelMapOverlayImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::LabelMapOverlayImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_LabelMapOverlayImageFilter

    def __init__(self):
        r"""__init__(LabelMapOverlayImageFilter self) -> LabelMapOverlayImageFilter"""
        _SimpleITK.LabelMapOverlayImageFilter_swiginit(self, _SimpleITK.new_LabelMapOverlayImageFilter())

    def SetOpacity(self, Opacity):
        r"""SetOpacity(LabelMapOverlayImageFilter self, double Opacity)"""
        return _SimpleITK.LabelMapOverlayImageFilter_SetOpacity(self, Opacity)

    def GetOpacity(self):
        r"""GetOpacity(LabelMapOverlayImageFilter self) -> double"""
        return _SimpleITK.LabelMapOverlayImageFilter_GetOpacity(self)

    def SetColormap(self, Colormap):
        r"""SetColormap(LabelMapOverlayImageFilter self, VectorUInt8 Colormap)"""
        return _SimpleITK.LabelMapOverlayImageFilter_SetColormap(self, Colormap)

    def GetColormap(self):
        r"""GetColormap(LabelMapOverlayImageFilter self) -> VectorUInt8"""
        return _SimpleITK.LabelMapOverlayImageFilter_GetColormap(self)

    def GetName(self):
        r"""GetName(LabelMapOverlayImageFilter self) -> std::string"""
        return _SimpleITK.LabelMapOverlayImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(LabelMapOverlayImageFilter self) -> std::string"""
        return _SimpleITK.LabelMapOverlayImageFilter___str__(self)

    def Execute(self, labelMapImage, featureImage):
        r"""Execute(LabelMapOverlayImageFilter self, Image labelMapImage, Image featureImage) -> Image"""
        return _SimpleITK.LabelMapOverlayImageFilter_Execute(self, labelMapImage, featureImage)

# Register LabelMapOverlayImageFilter in _SimpleITK:
_SimpleITK.LabelMapOverlayImageFilter_swigregister(LabelMapOverlayImageFilter)

def LabelMapOverlay(*args, **kwargs):
    r"""LabelMapOverlay(Image labelMapImage, Image featureImage, double opacity=0.5, VectorUInt8 colormap=std::vector< unsigned char >()) -> Image"""
    return _SimpleITK.LabelMapOverlay(*args, **kwargs)
class LabelMapToBinaryImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::LabelMapToBinaryImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_LabelMapToBinaryImageFilter

    def __init__(self):
        r"""__init__(LabelMapToBinaryImageFilter self) -> LabelMapToBinaryImageFilter"""
        _SimpleITK.LabelMapToBinaryImageFilter_swiginit(self, _SimpleITK.new_LabelMapToBinaryImageFilter())

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(LabelMapToBinaryImageFilter self, double BackgroundValue)"""
        return _SimpleITK.LabelMapToBinaryImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(LabelMapToBinaryImageFilter self) -> double"""
        return _SimpleITK.LabelMapToBinaryImageFilter_GetBackgroundValue(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(LabelMapToBinaryImageFilter self, double ForegroundValue)"""
        return _SimpleITK.LabelMapToBinaryImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(LabelMapToBinaryImageFilter self) -> double"""
        return _SimpleITK.LabelMapToBinaryImageFilter_GetForegroundValue(self)

    def GetName(self):
        r"""GetName(LabelMapToBinaryImageFilter self) -> std::string"""
        return _SimpleITK.LabelMapToBinaryImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(LabelMapToBinaryImageFilter self) -> std::string"""
        return _SimpleITK.LabelMapToBinaryImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(LabelMapToBinaryImageFilter self, Image image1) -> Image"""
        return _SimpleITK.LabelMapToBinaryImageFilter_Execute(self, image1)

# Register LabelMapToBinaryImageFilter in _SimpleITK:
_SimpleITK.LabelMapToBinaryImageFilter_swigregister(LabelMapToBinaryImageFilter)

def LabelMapToBinary(image1, backgroundValue=0, foregroundValue=1.0):
    r"""LabelMapToBinary(Image image1, double backgroundValue=0, double foregroundValue=1.0) -> Image"""
    return _SimpleITK.LabelMapToBinary(image1, backgroundValue, foregroundValue)
class LabelMapToLabelImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::LabelMapToLabelImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_LabelMapToLabelImageFilter

    def __init__(self):
        r"""__init__(LabelMapToLabelImageFilter self) -> LabelMapToLabelImageFilter"""
        _SimpleITK.LabelMapToLabelImageFilter_swiginit(self, _SimpleITK.new_LabelMapToLabelImageFilter())

    def GetName(self):
        r"""GetName(LabelMapToLabelImageFilter self) -> std::string"""
        return _SimpleITK.LabelMapToLabelImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(LabelMapToLabelImageFilter self) -> std::string"""
        return _SimpleITK.LabelMapToLabelImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(LabelMapToLabelImageFilter self, Image image1) -> Image"""
        return _SimpleITK.LabelMapToLabelImageFilter_Execute(self, image1)

# Register LabelMapToLabelImageFilter in _SimpleITK:
_SimpleITK.LabelMapToLabelImageFilter_swigregister(LabelMapToLabelImageFilter)

def LabelMapToLabel(image1):
    r"""LabelMapToLabel(Image image1) -> Image"""
    return _SimpleITK.LabelMapToLabel(image1)
class LabelMapToRGBImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::LabelMapToRGBImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_LabelMapToRGBImageFilter

    def __init__(self):
        r"""__init__(LabelMapToRGBImageFilter self) -> LabelMapToRGBImageFilter"""
        _SimpleITK.LabelMapToRGBImageFilter_swiginit(self, _SimpleITK.new_LabelMapToRGBImageFilter())

    def SetColormap(self, Colormap):
        r"""SetColormap(LabelMapToRGBImageFilter self, VectorUInt8 Colormap)"""
        return _SimpleITK.LabelMapToRGBImageFilter_SetColormap(self, Colormap)

    def GetColormap(self):
        r"""GetColormap(LabelMapToRGBImageFilter self) -> VectorUInt8"""
        return _SimpleITK.LabelMapToRGBImageFilter_GetColormap(self)

    def GetName(self):
        r"""GetName(LabelMapToRGBImageFilter self) -> std::string"""
        return _SimpleITK.LabelMapToRGBImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(LabelMapToRGBImageFilter self) -> std::string"""
        return _SimpleITK.LabelMapToRGBImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(LabelMapToRGBImageFilter self, Image image1) -> Image"""
        return _SimpleITK.LabelMapToRGBImageFilter_Execute(self, image1)

# Register LabelMapToRGBImageFilter in _SimpleITK:
_SimpleITK.LabelMapToRGBImageFilter_swigregister(LabelMapToRGBImageFilter)

def LabelMapToRGB(*args, **kwargs):
    r"""LabelMapToRGB(Image image1, VectorUInt8 colormap=std::vector< uint8_t >()) -> Image"""
    return _SimpleITK.LabelMapToRGB(*args, **kwargs)
class LabelOverlapMeasuresImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::LabelOverlapMeasuresImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_LabelOverlapMeasuresImageFilter

    def __init__(self):
        r"""__init__(LabelOverlapMeasuresImageFilter self) -> LabelOverlapMeasuresImageFilter"""
        _SimpleITK.LabelOverlapMeasuresImageFilter_swiginit(self, _SimpleITK.new_LabelOverlapMeasuresImageFilter())

    def GetFalseNegativeError(self, *args):
        r"""
        GetFalseNegativeError(LabelOverlapMeasuresImageFilter self) -> double
        GetFalseNegativeError(LabelOverlapMeasuresImageFilter self, int64_t label) -> double
        """
        return _SimpleITK.LabelOverlapMeasuresImageFilter_GetFalseNegativeError(self, *args)

    def GetFalsePositiveError(self, *args):
        r"""
        GetFalsePositiveError(LabelOverlapMeasuresImageFilter self) -> double
        GetFalsePositiveError(LabelOverlapMeasuresImageFilter self, int64_t label) -> double
        """
        return _SimpleITK.LabelOverlapMeasuresImageFilter_GetFalsePositiveError(self, *args)

    def GetMeanOverlap(self, *args):
        r"""
        GetMeanOverlap(LabelOverlapMeasuresImageFilter self) -> double
        GetMeanOverlap(LabelOverlapMeasuresImageFilter self, int64_t label) -> double
        """
        return _SimpleITK.LabelOverlapMeasuresImageFilter_GetMeanOverlap(self, *args)

    def GetUnionOverlap(self, *args):
        r"""
        GetUnionOverlap(LabelOverlapMeasuresImageFilter self) -> double
        GetUnionOverlap(LabelOverlapMeasuresImageFilter self, int64_t label) -> double
        """
        return _SimpleITK.LabelOverlapMeasuresImageFilter_GetUnionOverlap(self, *args)

    def GetVolumeSimilarity(self, *args):
        r"""
        GetVolumeSimilarity(LabelOverlapMeasuresImageFilter self) -> double
        GetVolumeSimilarity(LabelOverlapMeasuresImageFilter self, int64_t label) -> double
        """
        return _SimpleITK.LabelOverlapMeasuresImageFilter_GetVolumeSimilarity(self, *args)

    def GetJaccardCoefficient(self, *args):
        r"""
        GetJaccardCoefficient(LabelOverlapMeasuresImageFilter self) -> double
        GetJaccardCoefficient(LabelOverlapMeasuresImageFilter self, int64_t label) -> double
        """
        return _SimpleITK.LabelOverlapMeasuresImageFilter_GetJaccardCoefficient(self, *args)

    def GetDiceCoefficient(self, *args):
        r"""
        GetDiceCoefficient(LabelOverlapMeasuresImageFilter self) -> double
        GetDiceCoefficient(LabelOverlapMeasuresImageFilter self, int64_t label) -> double
        """
        return _SimpleITK.LabelOverlapMeasuresImageFilter_GetDiceCoefficient(self, *args)

    def GetFalseDiscoveryRate(self, *args):
        r"""
        GetFalseDiscoveryRate(LabelOverlapMeasuresImageFilter self) -> double
        GetFalseDiscoveryRate(LabelOverlapMeasuresImageFilter self, int64_t label) -> double
        """
        return _SimpleITK.LabelOverlapMeasuresImageFilter_GetFalseDiscoveryRate(self, *args)

    def GetName(self):
        r"""GetName(LabelOverlapMeasuresImageFilter self) -> std::string"""
        return _SimpleITK.LabelOverlapMeasuresImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(LabelOverlapMeasuresImageFilter self) -> std::string"""
        return _SimpleITK.LabelOverlapMeasuresImageFilter___str__(self)

    def Execute(self, sourceImage, targetImage):
        r"""Execute(LabelOverlapMeasuresImageFilter self, Image sourceImage, Image targetImage)"""
        return _SimpleITK.LabelOverlapMeasuresImageFilter_Execute(self, sourceImage, targetImage)

# Register LabelOverlapMeasuresImageFilter in _SimpleITK:
_SimpleITK.LabelOverlapMeasuresImageFilter_swigregister(LabelOverlapMeasuresImageFilter)
class LabelOverlayImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::LabelOverlayImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_LabelOverlayImageFilter

    def __init__(self):
        r"""__init__(LabelOverlayImageFilter self) -> LabelOverlayImageFilter"""
        _SimpleITK.LabelOverlayImageFilter_swiginit(self, _SimpleITK.new_LabelOverlayImageFilter())

    def SetOpacity(self, Opacity):
        r"""SetOpacity(LabelOverlayImageFilter self, double Opacity)"""
        return _SimpleITK.LabelOverlayImageFilter_SetOpacity(self, Opacity)

    def GetOpacity(self):
        r"""GetOpacity(LabelOverlayImageFilter self) -> double"""
        return _SimpleITK.LabelOverlayImageFilter_GetOpacity(self)

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(LabelOverlayImageFilter self, double BackgroundValue)"""
        return _SimpleITK.LabelOverlayImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(LabelOverlayImageFilter self) -> double"""
        return _SimpleITK.LabelOverlayImageFilter_GetBackgroundValue(self)

    def SetColormap(self, Colormap):
        r"""SetColormap(LabelOverlayImageFilter self, VectorUInt8 Colormap)"""
        return _SimpleITK.LabelOverlayImageFilter_SetColormap(self, Colormap)

    def GetColormap(self):
        r"""GetColormap(LabelOverlayImageFilter self) -> VectorUInt8"""
        return _SimpleITK.LabelOverlayImageFilter_GetColormap(self)

    def GetName(self):
        r"""GetName(LabelOverlayImageFilter self) -> std::string"""
        return _SimpleITK.LabelOverlayImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(LabelOverlayImageFilter self) -> std::string"""
        return _SimpleITK.LabelOverlayImageFilter___str__(self)

    def Execute(self, image, labelImage):
        r"""Execute(LabelOverlayImageFilter self, Image image, Image labelImage) -> Image"""
        return _SimpleITK.LabelOverlayImageFilter_Execute(self, image, labelImage)

# Register LabelOverlayImageFilter in _SimpleITK:
_SimpleITK.LabelOverlayImageFilter_swigregister(LabelOverlayImageFilter)

def LabelOverlay(*args, **kwargs):
    r"""LabelOverlay(Image image, Image labelImage, double opacity=0.5, double backgroundValue=0.0, VectorUInt8 colormap=std::vector< uint8_t >()) -> Image"""
    return _SimpleITK.LabelOverlay(*args, **kwargs)
class LabelShapeStatisticsImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::LabelShapeStatisticsImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_LabelShapeStatisticsImageFilter

    def __init__(self):
        r"""__init__(LabelShapeStatisticsImageFilter self) -> LabelShapeStatisticsImageFilter"""
        _SimpleITK.LabelShapeStatisticsImageFilter_swiginit(self, _SimpleITK.new_LabelShapeStatisticsImageFilter())

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(LabelShapeStatisticsImageFilter self, double BackgroundValue)"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(LabelShapeStatisticsImageFilter self) -> double"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetBackgroundValue(self)

    def SetComputeFeretDiameter(self, ComputeFeretDiameter):
        r"""SetComputeFeretDiameter(LabelShapeStatisticsImageFilter self, bool ComputeFeretDiameter)"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_SetComputeFeretDiameter(self, ComputeFeretDiameter)

    def ComputeFeretDiameterOn(self):
        r"""ComputeFeretDiameterOn(LabelShapeStatisticsImageFilter self)"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_ComputeFeretDiameterOn(self)

    def ComputeFeretDiameterOff(self):
        r"""ComputeFeretDiameterOff(LabelShapeStatisticsImageFilter self)"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_ComputeFeretDiameterOff(self)

    def GetComputeFeretDiameter(self):
        r"""GetComputeFeretDiameter(LabelShapeStatisticsImageFilter self) -> bool"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetComputeFeretDiameter(self)

    def SetComputePerimeter(self, ComputePerimeter):
        r"""SetComputePerimeter(LabelShapeStatisticsImageFilter self, bool ComputePerimeter)"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_SetComputePerimeter(self, ComputePerimeter)

    def ComputePerimeterOn(self):
        r"""ComputePerimeterOn(LabelShapeStatisticsImageFilter self)"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_ComputePerimeterOn(self)

    def ComputePerimeterOff(self):
        r"""ComputePerimeterOff(LabelShapeStatisticsImageFilter self)"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_ComputePerimeterOff(self)

    def GetComputePerimeter(self):
        r"""GetComputePerimeter(LabelShapeStatisticsImageFilter self) -> bool"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetComputePerimeter(self)

    def SetComputeOrientedBoundingBox(self, ComputeOrientedBoundingBox):
        r"""SetComputeOrientedBoundingBox(LabelShapeStatisticsImageFilter self, bool ComputeOrientedBoundingBox)"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_SetComputeOrientedBoundingBox(self, ComputeOrientedBoundingBox)

    def ComputeOrientedBoundingBoxOn(self):
        r"""ComputeOrientedBoundingBoxOn(LabelShapeStatisticsImageFilter self)"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_ComputeOrientedBoundingBoxOn(self)

    def ComputeOrientedBoundingBoxOff(self):
        r"""ComputeOrientedBoundingBoxOff(LabelShapeStatisticsImageFilter self)"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_ComputeOrientedBoundingBoxOff(self)

    def GetComputeOrientedBoundingBox(self):
        r"""GetComputeOrientedBoundingBox(LabelShapeStatisticsImageFilter self) -> bool"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetComputeOrientedBoundingBox(self)

    def GetBoundingBox(self, label):
        r"""GetBoundingBox(LabelShapeStatisticsImageFilter self, int64_t label) -> VectorUInt32"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetBoundingBox(self, label)

    def GetRegion(self, label):
        r"""GetRegion(LabelShapeStatisticsImageFilter self, int64_t label) -> VectorUInt32"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetRegion(self, label)

    def GetCentroid(self, label):
        r"""GetCentroid(LabelShapeStatisticsImageFilter self, int64_t label) -> VectorDouble"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetCentroid(self, label)

    def GetElongation(self, label):
        r"""GetElongation(LabelShapeStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetElongation(self, label)

    def GetEquivalentEllipsoidDiameter(self, label):
        r"""GetEquivalentEllipsoidDiameter(LabelShapeStatisticsImageFilter self, int64_t label) -> VectorDouble"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetEquivalentEllipsoidDiameter(self, label)

    def GetEquivalentSphericalPerimeter(self, label):
        r"""GetEquivalentSphericalPerimeter(LabelShapeStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetEquivalentSphericalPerimeter(self, label)

    def GetEquivalentSphericalRadius(self, label):
        r"""GetEquivalentSphericalRadius(LabelShapeStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetEquivalentSphericalRadius(self, label)

    def GetFeretDiameter(self, label):
        r"""GetFeretDiameter(LabelShapeStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetFeretDiameter(self, label)

    def GetFlatness(self, label):
        r"""GetFlatness(LabelShapeStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetFlatness(self, label)

    def GetLabels(self):
        r"""GetLabels(LabelShapeStatisticsImageFilter self) -> VectorInt64"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetLabels(self)

    def GetNumberOfPixels(self, label):
        r"""GetNumberOfPixels(LabelShapeStatisticsImageFilter self, int64_t label) -> uint64_t"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetNumberOfPixels(self, label)

    def GetNumberOfPixelsOnBorder(self, label):
        r"""GetNumberOfPixelsOnBorder(LabelShapeStatisticsImageFilter self, int64_t label) -> uint64_t"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetNumberOfPixelsOnBorder(self, label)

    def GetPerimeter(self, label):
        r"""GetPerimeter(LabelShapeStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetPerimeter(self, label)

    def GetPerimeterOnBorder(self, label):
        r"""GetPerimeterOnBorder(LabelShapeStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetPerimeterOnBorder(self, label)

    def GetPerimeterOnBorderRatio(self, label):
        r"""GetPerimeterOnBorderRatio(LabelShapeStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetPerimeterOnBorderRatio(self, label)

    def GetPhysicalSize(self, label):
        r"""GetPhysicalSize(LabelShapeStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetPhysicalSize(self, label)

    def GetPrincipalAxes(self, label):
        r"""GetPrincipalAxes(LabelShapeStatisticsImageFilter self, int64_t label) -> VectorDouble"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetPrincipalAxes(self, label)

    def GetPrincipalMoments(self, label):
        r"""GetPrincipalMoments(LabelShapeStatisticsImageFilter self, int64_t label) -> VectorDouble"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetPrincipalMoments(self, label)

    def GetRoundness(self, label):
        r"""GetRoundness(LabelShapeStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetRoundness(self, label)

    def GetOrientedBoundingBoxSize(self, label):
        r"""GetOrientedBoundingBoxSize(LabelShapeStatisticsImageFilter self, int64_t label) -> VectorDouble"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetOrientedBoundingBoxSize(self, label)

    def GetOrientedBoundingBoxOrigin(self, label):
        r"""GetOrientedBoundingBoxOrigin(LabelShapeStatisticsImageFilter self, int64_t label) -> VectorDouble"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetOrientedBoundingBoxOrigin(self, label)

    def GetOrientedBoundingBoxDirection(self, label):
        r"""GetOrientedBoundingBoxDirection(LabelShapeStatisticsImageFilter self, int64_t label) -> VectorDouble"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetOrientedBoundingBoxDirection(self, label)

    def GetOrientedBoundingBoxVertices(self, label):
        r"""GetOrientedBoundingBoxVertices(LabelShapeStatisticsImageFilter self, int64_t label) -> VectorDouble"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetOrientedBoundingBoxVertices(self, label)

    def GetIndexes(self, label):
        r"""GetIndexes(LabelShapeStatisticsImageFilter self, int64_t label) -> VectorUInt32"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetIndexes(self, label)

    def GetRLEIndexes(self, label):
        r"""GetRLEIndexes(LabelShapeStatisticsImageFilter self, int64_t label) -> VectorUInt32"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetRLEIndexes(self, label)

    def GetName(self):
        r"""GetName(LabelShapeStatisticsImageFilter self) -> std::string"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(LabelShapeStatisticsImageFilter self) -> std::string"""
        return _SimpleITK.LabelShapeStatisticsImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(LabelShapeStatisticsImageFilter self, Image image1)"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_Execute(self, image1)

    def HasLabel(self, label):
        r"""HasLabel(LabelShapeStatisticsImageFilter self, int64_t label) -> bool"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_HasLabel(self, label)

    def GetNumberOfLabels(self):
        r"""GetNumberOfLabels(LabelShapeStatisticsImageFilter self) -> uint64_t"""
        return _SimpleITK.LabelShapeStatisticsImageFilter_GetNumberOfLabels(self)

# Register LabelShapeStatisticsImageFilter in _SimpleITK:
_SimpleITK.LabelShapeStatisticsImageFilter_swigregister(LabelShapeStatisticsImageFilter)
class LabelStatisticsImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::LabelStatisticsImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_LabelStatisticsImageFilter

    def __init__(self):
        r"""__init__(LabelStatisticsImageFilter self) -> LabelStatisticsImageFilter"""
        _SimpleITK.LabelStatisticsImageFilter_swiginit(self, _SimpleITK.new_LabelStatisticsImageFilter())

    def SetUseHistograms(self, UseHistograms):
        r"""SetUseHistograms(LabelStatisticsImageFilter self, bool UseHistograms)"""
        return _SimpleITK.LabelStatisticsImageFilter_SetUseHistograms(self, UseHistograms)

    def UseHistogramsOn(self):
        r"""UseHistogramsOn(LabelStatisticsImageFilter self)"""
        return _SimpleITK.LabelStatisticsImageFilter_UseHistogramsOn(self)

    def UseHistogramsOff(self):
        r"""UseHistogramsOff(LabelStatisticsImageFilter self)"""
        return _SimpleITK.LabelStatisticsImageFilter_UseHistogramsOff(self)

    def GetUseHistograms(self):
        r"""GetUseHistograms(LabelStatisticsImageFilter self) -> bool"""
        return _SimpleITK.LabelStatisticsImageFilter_GetUseHistograms(self)

    def GetMinimum(self, label):
        r"""GetMinimum(LabelStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelStatisticsImageFilter_GetMinimum(self, label)

    def GetMaximum(self, label):
        r"""GetMaximum(LabelStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelStatisticsImageFilter_GetMaximum(self, label)

    def GetMean(self, label):
        r"""GetMean(LabelStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelStatisticsImageFilter_GetMean(self, label)

    def GetMedian(self, label):
        r"""GetMedian(LabelStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelStatisticsImageFilter_GetMedian(self, label)

    def GetSigma(self, label):
        r"""GetSigma(LabelStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelStatisticsImageFilter_GetSigma(self, label)

    def GetVariance(self, label):
        r"""GetVariance(LabelStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelStatisticsImageFilter_GetVariance(self, label)

    def GetSum(self, label):
        r"""GetSum(LabelStatisticsImageFilter self, int64_t label) -> double"""
        return _SimpleITK.LabelStatisticsImageFilter_GetSum(self, label)

    def GetCount(self, label):
        r"""GetCount(LabelStatisticsImageFilter self, int64_t label) -> uint64_t"""
        return _SimpleITK.LabelStatisticsImageFilter_GetCount(self, label)

    def GetBoundingBox(self, label):
        r"""GetBoundingBox(LabelStatisticsImageFilter self, int64_t label) -> VectorInt32"""
        return _SimpleITK.LabelStatisticsImageFilter_GetBoundingBox(self, label)

    def GetRegion(self, label):
        r"""GetRegion(LabelStatisticsImageFilter self, int64_t label) -> VectorUInt32"""
        return _SimpleITK.LabelStatisticsImageFilter_GetRegion(self, label)

    def GetLabels(self):
        r"""GetLabels(LabelStatisticsImageFilter self) -> VectorInt64"""
        return _SimpleITK.LabelStatisticsImageFilter_GetLabels(self)

    def GetName(self):
        r"""GetName(LabelStatisticsImageFilter self) -> std::string"""
        return _SimpleITK.LabelStatisticsImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(LabelStatisticsImageFilter self) -> std::string"""
        return _SimpleITK.LabelStatisticsImageFilter___str__(self)

    def Execute(self, image, labelImage):
        r"""Execute(LabelStatisticsImageFilter self, Image image, Image labelImage)"""
        return _SimpleITK.LabelStatisticsImageFilter_Execute(self, image, labelImage)

    def HasLabel(self, label):
        r"""HasLabel(LabelStatisticsImageFilter self, int64_t label) -> bool"""
        return _SimpleITK.LabelStatisticsImageFilter_HasLabel(self, label)

    def GetNumberOfLabels(self):
        r"""GetNumberOfLabels(LabelStatisticsImageFilter self) -> uint64_t"""
        return _SimpleITK.LabelStatisticsImageFilter_GetNumberOfLabels(self)

# Register LabelStatisticsImageFilter in _SimpleITK:
_SimpleITK.LabelStatisticsImageFilter_swigregister(LabelStatisticsImageFilter)
class LabelToRGBImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::LabelToRGBImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_LabelToRGBImageFilter

    def __init__(self):
        r"""__init__(LabelToRGBImageFilter self) -> LabelToRGBImageFilter"""
        _SimpleITK.LabelToRGBImageFilter_swiginit(self, _SimpleITK.new_LabelToRGBImageFilter())

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(LabelToRGBImageFilter self, double BackgroundValue)"""
        return _SimpleITK.LabelToRGBImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(LabelToRGBImageFilter self) -> double"""
        return _SimpleITK.LabelToRGBImageFilter_GetBackgroundValue(self)

    def SetColormap(self, Colormap):
        r"""SetColormap(LabelToRGBImageFilter self, VectorUInt8 Colormap)"""
        return _SimpleITK.LabelToRGBImageFilter_SetColormap(self, Colormap)

    def GetColormap(self):
        r"""GetColormap(LabelToRGBImageFilter self) -> VectorUInt8"""
        return _SimpleITK.LabelToRGBImageFilter_GetColormap(self)

    def GetName(self):
        r"""GetName(LabelToRGBImageFilter self) -> std::string"""
        return _SimpleITK.LabelToRGBImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(LabelToRGBImageFilter self) -> std::string"""
        return _SimpleITK.LabelToRGBImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(LabelToRGBImageFilter self, Image image1) -> Image"""
        return _SimpleITK.LabelToRGBImageFilter_Execute(self, image1)

# Register LabelToRGBImageFilter in _SimpleITK:
_SimpleITK.LabelToRGBImageFilter_swigregister(LabelToRGBImageFilter)

def LabelToRGB(*args, **kwargs):
    r"""LabelToRGB(Image image1, double backgroundValue=0.0, VectorUInt8 colormap=std::vector< uint8_t >()) -> Image"""
    return _SimpleITK.LabelToRGB(*args, **kwargs)
class LabelUniqueLabelMapFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::LabelUniqueLabelMapFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_LabelUniqueLabelMapFilter

    def __init__(self):
        r"""__init__(LabelUniqueLabelMapFilter self) -> LabelUniqueLabelMapFilter"""
        _SimpleITK.LabelUniqueLabelMapFilter_swiginit(self, _SimpleITK.new_LabelUniqueLabelMapFilter())

    def SetReverseOrdering(self, ReverseOrdering):
        r"""SetReverseOrdering(LabelUniqueLabelMapFilter self, bool ReverseOrdering)"""
        return _SimpleITK.LabelUniqueLabelMapFilter_SetReverseOrdering(self, ReverseOrdering)

    def ReverseOrderingOn(self):
        r"""ReverseOrderingOn(LabelUniqueLabelMapFilter self)"""
        return _SimpleITK.LabelUniqueLabelMapFilter_ReverseOrderingOn(self)

    def ReverseOrderingOff(self):
        r"""ReverseOrderingOff(LabelUniqueLabelMapFilter self)"""
        return _SimpleITK.LabelUniqueLabelMapFilter_ReverseOrderingOff(self)

    def GetReverseOrdering(self):
        r"""GetReverseOrdering(LabelUniqueLabelMapFilter self) -> bool"""
        return _SimpleITK.LabelUniqueLabelMapFilter_GetReverseOrdering(self)

    def GetName(self):
        r"""GetName(LabelUniqueLabelMapFilter self) -> std::string"""
        return _SimpleITK.LabelUniqueLabelMapFilter_GetName(self)

    def __str__(self):
        r"""__str__(LabelUniqueLabelMapFilter self) -> std::string"""
        return _SimpleITK.LabelUniqueLabelMapFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(LabelUniqueLabelMapFilter self, Image image1) -> Image"""
        return _SimpleITK.LabelUniqueLabelMapFilter_Execute(self, image1)

# Register LabelUniqueLabelMapFilter in _SimpleITK:
_SimpleITK.LabelUniqueLabelMapFilter_swigregister(LabelUniqueLabelMapFilter)

def LabelUniqueLabelMap(image1, reverseOrdering=False):
    r"""LabelUniqueLabelMap(Image image1, bool reverseOrdering=False) -> Image"""
    return _SimpleITK.LabelUniqueLabelMap(image1, reverseOrdering)
class LabelVotingImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::LabelVotingImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_LabelVotingImageFilter

    def __init__(self):
        r"""__init__(LabelVotingImageFilter self) -> LabelVotingImageFilter"""
        _SimpleITK.LabelVotingImageFilter_swiginit(self, _SimpleITK.new_LabelVotingImageFilter())

    def SetLabelForUndecidedPixels(self, LabelForUndecidedPixels):
        r"""SetLabelForUndecidedPixels(LabelVotingImageFilter self, uint64_t LabelForUndecidedPixels)"""
        return _SimpleITK.LabelVotingImageFilter_SetLabelForUndecidedPixels(self, LabelForUndecidedPixels)

    def GetLabelForUndecidedPixels(self):
        r"""GetLabelForUndecidedPixels(LabelVotingImageFilter self) -> uint64_t"""
        return _SimpleITK.LabelVotingImageFilter_GetLabelForUndecidedPixels(self)

    def GetName(self):
        r"""GetName(LabelVotingImageFilter self) -> std::string"""
        return _SimpleITK.LabelVotingImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(LabelVotingImageFilter self) -> std::string"""
        return _SimpleITK.LabelVotingImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(LabelVotingImageFilter self, VectorOfImage images) -> Image
        Execute(LabelVotingImageFilter self, Image image1) -> Image
        Execute(LabelVotingImageFilter self, Image image1, Image image2) -> Image
        Execute(LabelVotingImageFilter self, Image image1, Image image2, Image image3) -> Image
        Execute(LabelVotingImageFilter self, Image image1, Image image2, Image image3, Image image4) -> Image
        Execute(LabelVotingImageFilter self, Image image1, Image image2, Image image3, Image image4, Image image5) -> Image
        """
        return _SimpleITK.LabelVotingImageFilter_Execute(self, *args)

# Register LabelVotingImageFilter in _SimpleITK:
_SimpleITK.LabelVotingImageFilter_swigregister(LabelVotingImageFilter)

def LabelVoting(*args):
    r"""
    LabelVoting(VectorOfImage images, uint64_t labelForUndecidedPixels=std::numeric_limits< uint64_t >::max()) -> Image
    LabelVoting(Image image1, uint64_t labelForUndecidedPixels=std::numeric_limits< uint64_t >::max()) -> Image
    LabelVoting(Image image1, Image image2, uint64_t labelForUndecidedPixels=std::numeric_limits< uint64_t >::max()) -> Image
    LabelVoting(Image image1, Image image2, Image image3, uint64_t labelForUndecidedPixels=std::numeric_limits< uint64_t >::max()) -> Image
    LabelVoting(Image image1, Image image2, Image image3, Image image4, uint64_t labelForUndecidedPixels=std::numeric_limits< uint64_t >::max()) -> Image
    LabelVoting(Image image1, Image image2, Image image3, Image image4, Image image5, uint64_t labelForUndecidedPixels=std::numeric_limits< uint64_t >::max()) -> Image
    """
    return _SimpleITK.LabelVoting(*args)
class LandweberDeconvolutionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::LandweberDeconvolutionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_LandweberDeconvolutionImageFilter

    def __init__(self):
        r"""__init__(LandweberDeconvolutionImageFilter self) -> LandweberDeconvolutionImageFilter"""
        _SimpleITK.LandweberDeconvolutionImageFilter_swiginit(self, _SimpleITK.new_LandweberDeconvolutionImageFilter())

    def SetAlpha(self, Alpha):
        r"""SetAlpha(LandweberDeconvolutionImageFilter self, double Alpha)"""
        return _SimpleITK.LandweberDeconvolutionImageFilter_SetAlpha(self, Alpha)

    def GetAlpha(self):
        r"""GetAlpha(LandweberDeconvolutionImageFilter self) -> double"""
        return _SimpleITK.LandweberDeconvolutionImageFilter_GetAlpha(self)

    def SetNumberOfIterations(self, NumberOfIterations):
        r"""SetNumberOfIterations(LandweberDeconvolutionImageFilter self, int NumberOfIterations)"""
        return _SimpleITK.LandweberDeconvolutionImageFilter_SetNumberOfIterations(self, NumberOfIterations)

    def GetNumberOfIterations(self):
        r"""GetNumberOfIterations(LandweberDeconvolutionImageFilter self) -> int"""
        return _SimpleITK.LandweberDeconvolutionImageFilter_GetNumberOfIterations(self)

    def SetNormalize(self, Normalize):
        r"""SetNormalize(LandweberDeconvolutionImageFilter self, bool Normalize)"""
        return _SimpleITK.LandweberDeconvolutionImageFilter_SetNormalize(self, Normalize)

    def NormalizeOn(self):
        r"""NormalizeOn(LandweberDeconvolutionImageFilter self)"""
        return _SimpleITK.LandweberDeconvolutionImageFilter_NormalizeOn(self)

    def NormalizeOff(self):
        r"""NormalizeOff(LandweberDeconvolutionImageFilter self)"""
        return _SimpleITK.LandweberDeconvolutionImageFilter_NormalizeOff(self)

    def GetNormalize(self):
        r"""GetNormalize(LandweberDeconvolutionImageFilter self) -> bool"""
        return _SimpleITK.LandweberDeconvolutionImageFilter_GetNormalize(self)
    ZERO_PAD = _SimpleITK.LandweberDeconvolutionImageFilter_ZERO_PAD
    
    ZERO_FLUX_NEUMANN_PAD = _SimpleITK.LandweberDeconvolutionImageFilter_ZERO_FLUX_NEUMANN_PAD
    
    PERIODIC_PAD = _SimpleITK.LandweberDeconvolutionImageFilter_PERIODIC_PAD
    

    def SetBoundaryCondition(self, BoundaryCondition):
        r"""SetBoundaryCondition(LandweberDeconvolutionImageFilter self, slicer_itk::simple::LandweberDeconvolutionImageFilter::BoundaryConditionType BoundaryCondition)"""
        return _SimpleITK.LandweberDeconvolutionImageFilter_SetBoundaryCondition(self, BoundaryCondition)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(LandweberDeconvolutionImageFilter self) -> slicer_itk::simple::LandweberDeconvolutionImageFilter::BoundaryConditionType"""
        return _SimpleITK.LandweberDeconvolutionImageFilter_GetBoundaryCondition(self)
    SAME = _SimpleITK.LandweberDeconvolutionImageFilter_SAME
    
    VALID = _SimpleITK.LandweberDeconvolutionImageFilter_VALID
    

    def SetOutputRegionMode(self, OutputRegionMode):
        r"""SetOutputRegionMode(LandweberDeconvolutionImageFilter self, slicer_itk::simple::LandweberDeconvolutionImageFilter::OutputRegionModeType OutputRegionMode)"""
        return _SimpleITK.LandweberDeconvolutionImageFilter_SetOutputRegionMode(self, OutputRegionMode)

    def GetOutputRegionMode(self):
        r"""GetOutputRegionMode(LandweberDeconvolutionImageFilter self) -> slicer_itk::simple::LandweberDeconvolutionImageFilter::OutputRegionModeType"""
        return _SimpleITK.LandweberDeconvolutionImageFilter_GetOutputRegionMode(self)

    def GetName(self):
        r"""GetName(LandweberDeconvolutionImageFilter self) -> std::string"""
        return _SimpleITK.LandweberDeconvolutionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(LandweberDeconvolutionImageFilter self) -> std::string"""
        return _SimpleITK.LandweberDeconvolutionImageFilter___str__(self)

    def Execute(self, image1, image2):
        r"""Execute(LandweberDeconvolutionImageFilter self, Image image1, Image image2) -> Image"""
        return _SimpleITK.LandweberDeconvolutionImageFilter_Execute(self, image1, image2)

# Register LandweberDeconvolutionImageFilter in _SimpleITK:
_SimpleITK.LandweberDeconvolutionImageFilter_swigregister(LandweberDeconvolutionImageFilter)

def LandweberDeconvolution(*args, **kwargs):
    r"""LandweberDeconvolution(Image image1, Image image2, double alpha=0.1, int numberOfIterations=1, bool normalize=False, slicer_itk::simple::LandweberDeconvolutionImageFilter::BoundaryConditionType boundaryCondition=ZERO_FLUX_NEUMANN_PAD, slicer_itk::simple::LandweberDeconvolutionImageFilter::OutputRegionModeType outputRegionMode=SAME) -> Image"""
    return _SimpleITK.LandweberDeconvolution(*args, **kwargs)
class LaplacianImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::LaplacianImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_LaplacianImageFilter

    def __init__(self):
        r"""__init__(LaplacianImageFilter self) -> LaplacianImageFilter"""
        _SimpleITK.LaplacianImageFilter_swiginit(self, _SimpleITK.new_LaplacianImageFilter())

    def SetUseImageSpacing(self, UseImageSpacing):
        r"""SetUseImageSpacing(LaplacianImageFilter self, bool UseImageSpacing)"""
        return _SimpleITK.LaplacianImageFilter_SetUseImageSpacing(self, UseImageSpacing)

    def UseImageSpacingOn(self):
        r"""UseImageSpacingOn(LaplacianImageFilter self)"""
        return _SimpleITK.LaplacianImageFilter_UseImageSpacingOn(self)

    def UseImageSpacingOff(self):
        r"""UseImageSpacingOff(LaplacianImageFilter self)"""
        return _SimpleITK.LaplacianImageFilter_UseImageSpacingOff(self)

    def GetUseImageSpacing(self):
        r"""GetUseImageSpacing(LaplacianImageFilter self) -> bool"""
        return _SimpleITK.LaplacianImageFilter_GetUseImageSpacing(self)

    def GetName(self):
        r"""GetName(LaplacianImageFilter self) -> std::string"""
        return _SimpleITK.LaplacianImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(LaplacianImageFilter self) -> std::string"""
        return _SimpleITK.LaplacianImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(LaplacianImageFilter self, Image image1) -> Image"""
        return _SimpleITK.LaplacianImageFilter_Execute(self, image1)

# Register LaplacianImageFilter in _SimpleITK:
_SimpleITK.LaplacianImageFilter_swigregister(LaplacianImageFilter)

def Laplacian(image1, useImageSpacing=True):
    r"""Laplacian(Image image1, bool useImageSpacing=True) -> Image"""
    return _SimpleITK.Laplacian(image1, useImageSpacing)
class LaplacianRecursiveGaussianImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::LaplacianRecursiveGaussianImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_LaplacianRecursiveGaussianImageFilter

    def __init__(self):
        r"""__init__(LaplacianRecursiveGaussianImageFilter self) -> LaplacianRecursiveGaussianImageFilter"""
        _SimpleITK.LaplacianRecursiveGaussianImageFilter_swiginit(self, _SimpleITK.new_LaplacianRecursiveGaussianImageFilter())

    def SetSigma(self, Sigma):
        r"""SetSigma(LaplacianRecursiveGaussianImageFilter self, double Sigma)"""
        return _SimpleITK.LaplacianRecursiveGaussianImageFilter_SetSigma(self, Sigma)

    def GetSigma(self):
        r"""GetSigma(LaplacianRecursiveGaussianImageFilter self) -> double"""
        return _SimpleITK.LaplacianRecursiveGaussianImageFilter_GetSigma(self)

    def SetNormalizeAcrossScale(self, NormalizeAcrossScale):
        r"""SetNormalizeAcrossScale(LaplacianRecursiveGaussianImageFilter self, bool NormalizeAcrossScale)"""
        return _SimpleITK.LaplacianRecursiveGaussianImageFilter_SetNormalizeAcrossScale(self, NormalizeAcrossScale)

    def NormalizeAcrossScaleOn(self):
        r"""NormalizeAcrossScaleOn(LaplacianRecursiveGaussianImageFilter self)"""
        return _SimpleITK.LaplacianRecursiveGaussianImageFilter_NormalizeAcrossScaleOn(self)

    def NormalizeAcrossScaleOff(self):
        r"""NormalizeAcrossScaleOff(LaplacianRecursiveGaussianImageFilter self)"""
        return _SimpleITK.LaplacianRecursiveGaussianImageFilter_NormalizeAcrossScaleOff(self)

    def GetNormalizeAcrossScale(self):
        r"""GetNormalizeAcrossScale(LaplacianRecursiveGaussianImageFilter self) -> bool"""
        return _SimpleITK.LaplacianRecursiveGaussianImageFilter_GetNormalizeAcrossScale(self)

    def GetName(self):
        r"""GetName(LaplacianRecursiveGaussianImageFilter self) -> std::string"""
        return _SimpleITK.LaplacianRecursiveGaussianImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(LaplacianRecursiveGaussianImageFilter self) -> std::string"""
        return _SimpleITK.LaplacianRecursiveGaussianImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(LaplacianRecursiveGaussianImageFilter self, Image image1) -> Image"""
        return _SimpleITK.LaplacianRecursiveGaussianImageFilter_Execute(self, image1)

# Register LaplacianRecursiveGaussianImageFilter in _SimpleITK:
_SimpleITK.LaplacianRecursiveGaussianImageFilter_swigregister(LaplacianRecursiveGaussianImageFilter)

def LaplacianRecursiveGaussian(image1, sigma=1.0, normalizeAcrossScale=False):
    r"""LaplacianRecursiveGaussian(Image image1, double sigma=1.0, bool normalizeAcrossScale=False) -> Image"""
    return _SimpleITK.LaplacianRecursiveGaussian(image1, sigma, normalizeAcrossScale)
class LaplacianSegmentationLevelSetImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::LaplacianSegmentationLevelSetImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_LaplacianSegmentationLevelSetImageFilter

    def __init__(self):
        r"""__init__(LaplacianSegmentationLevelSetImageFilter self) -> LaplacianSegmentationLevelSetImageFilter"""
        _SimpleITK.LaplacianSegmentationLevelSetImageFilter_swiginit(self, _SimpleITK.new_LaplacianSegmentationLevelSetImageFilter())

    def SetMaximumRMSError(self, MaximumRMSError):
        r"""SetMaximumRMSError(LaplacianSegmentationLevelSetImageFilter self, double MaximumRMSError)"""
        return _SimpleITK.LaplacianSegmentationLevelSetImageFilter_SetMaximumRMSError(self, MaximumRMSError)

    def GetMaximumRMSError(self):
        r"""GetMaximumRMSError(LaplacianSegmentationLevelSetImageFilter self) -> double"""
        return _SimpleITK.LaplacianSegmentationLevelSetImageFilter_GetMaximumRMSError(self)

    def SetPropagationScaling(self, PropagationScaling):
        r"""SetPropagationScaling(LaplacianSegmentationLevelSetImageFilter self, double PropagationScaling)"""
        return _SimpleITK.LaplacianSegmentationLevelSetImageFilter_SetPropagationScaling(self, PropagationScaling)

    def GetPropagationScaling(self):
        r"""GetPropagationScaling(LaplacianSegmentationLevelSetImageFilter self) -> double"""
        return _SimpleITK.LaplacianSegmentationLevelSetImageFilter_GetPropagationScaling(self)

    def SetCurvatureScaling(self, CurvatureScaling):
        r"""SetCurvatureScaling(LaplacianSegmentationLevelSetImageFilter self, double CurvatureScaling)"""
        return _SimpleITK.LaplacianSegmentationLevelSetImageFilter_SetCurvatureScaling(self, CurvatureScaling)

    def GetCurvatureScaling(self):
        r"""GetCurvatureScaling(LaplacianSegmentationLevelSetImageFilter self) -> double"""
        return _SimpleITK.LaplacianSegmentationLevelSetImageFilter_GetCurvatureScaling(self)

    def SetNumberOfIterations(self, NumberOfIterations):
        r"""SetNumberOfIterations(LaplacianSegmentationLevelSetImageFilter self, uint32_t NumberOfIterations)"""
        return _SimpleITK.LaplacianSegmentationLevelSetImageFilter_SetNumberOfIterations(self, NumberOfIterations)

    def GetNumberOfIterations(self):
        r"""GetNumberOfIterations(LaplacianSegmentationLevelSetImageFilter self) -> uint32_t"""
        return _SimpleITK.LaplacianSegmentationLevelSetImageFilter_GetNumberOfIterations(self)

    def SetReverseExpansionDirection(self, ReverseExpansionDirection):
        r"""SetReverseExpansionDirection(LaplacianSegmentationLevelSetImageFilter self, bool ReverseExpansionDirection)"""
        return _SimpleITK.LaplacianSegmentationLevelSetImageFilter_SetReverseExpansionDirection(self, ReverseExpansionDirection)

    def ReverseExpansionDirectionOn(self):
        r"""ReverseExpansionDirectionOn(LaplacianSegmentationLevelSetImageFilter self)"""
        return _SimpleITK.LaplacianSegmentationLevelSetImageFilter_ReverseExpansionDirectionOn(self)

    def ReverseExpansionDirectionOff(self):
        r"""ReverseExpansionDirectionOff(LaplacianSegmentationLevelSetImageFilter self)"""
        return _SimpleITK.LaplacianSegmentationLevelSetImageFilter_ReverseExpansionDirectionOff(self)

    def GetReverseExpansionDirection(self):
        r"""GetReverseExpansionDirection(LaplacianSegmentationLevelSetImageFilter self) -> bool"""
        return _SimpleITK.LaplacianSegmentationLevelSetImageFilter_GetReverseExpansionDirection(self)

    def GetElapsedIterations(self):
        r"""GetElapsedIterations(LaplacianSegmentationLevelSetImageFilter self) -> uint32_t"""
        return _SimpleITK.LaplacianSegmentationLevelSetImageFilter_GetElapsedIterations(self)

    def GetRMSChange(self):
        r"""GetRMSChange(LaplacianSegmentationLevelSetImageFilter self) -> double"""
        return _SimpleITK.LaplacianSegmentationLevelSetImageFilter_GetRMSChange(self)

    def GetName(self):
        r"""GetName(LaplacianSegmentationLevelSetImageFilter self) -> std::string"""
        return _SimpleITK.LaplacianSegmentationLevelSetImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(LaplacianSegmentationLevelSetImageFilter self) -> std::string"""
        return _SimpleITK.LaplacianSegmentationLevelSetImageFilter___str__(self)

    def Execute(self, initialImage, featureImage):
        r"""Execute(LaplacianSegmentationLevelSetImageFilter self, Image initialImage, Image featureImage) -> Image"""
        return _SimpleITK.LaplacianSegmentationLevelSetImageFilter_Execute(self, initialImage, featureImage)

# Register LaplacianSegmentationLevelSetImageFilter in _SimpleITK:
_SimpleITK.LaplacianSegmentationLevelSetImageFilter_swigregister(LaplacianSegmentationLevelSetImageFilter)

def LaplacianSegmentationLevelSet(initialImage, featureImage, maximumRMSError=0.02, propagationScaling=1.0, curvatureScaling=1.0, numberOfIterations=1000, reverseExpansionDirection=False):
    r"""LaplacianSegmentationLevelSet(Image initialImage, Image featureImage, double maximumRMSError=0.02, double propagationScaling=1.0, double curvatureScaling=1.0, uint32_t numberOfIterations=1000, bool reverseExpansionDirection=False) -> Image"""
    return _SimpleITK.LaplacianSegmentationLevelSet(initialImage, featureImage, maximumRMSError, propagationScaling, curvatureScaling, numberOfIterations, reverseExpansionDirection)
class LaplacianSharpeningImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::LaplacianSharpeningImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_LaplacianSharpeningImageFilter

    def __init__(self):
        r"""__init__(LaplacianSharpeningImageFilter self) -> LaplacianSharpeningImageFilter"""
        _SimpleITK.LaplacianSharpeningImageFilter_swiginit(self, _SimpleITK.new_LaplacianSharpeningImageFilter())

    def SetUseImageSpacing(self, UseImageSpacing):
        r"""SetUseImageSpacing(LaplacianSharpeningImageFilter self, bool UseImageSpacing)"""
        return _SimpleITK.LaplacianSharpeningImageFilter_SetUseImageSpacing(self, UseImageSpacing)

    def UseImageSpacingOn(self):
        r"""UseImageSpacingOn(LaplacianSharpeningImageFilter self)"""
        return _SimpleITK.LaplacianSharpeningImageFilter_UseImageSpacingOn(self)

    def UseImageSpacingOff(self):
        r"""UseImageSpacingOff(LaplacianSharpeningImageFilter self)"""
        return _SimpleITK.LaplacianSharpeningImageFilter_UseImageSpacingOff(self)

    def GetUseImageSpacing(self):
        r"""GetUseImageSpacing(LaplacianSharpeningImageFilter self) -> bool"""
        return _SimpleITK.LaplacianSharpeningImageFilter_GetUseImageSpacing(self)

    def GetName(self):
        r"""GetName(LaplacianSharpeningImageFilter self) -> std::string"""
        return _SimpleITK.LaplacianSharpeningImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(LaplacianSharpeningImageFilter self) -> std::string"""
        return _SimpleITK.LaplacianSharpeningImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(LaplacianSharpeningImageFilter self, Image image1) -> Image"""
        return _SimpleITK.LaplacianSharpeningImageFilter_Execute(self, image1)

# Register LaplacianSharpeningImageFilter in _SimpleITK:
_SimpleITK.LaplacianSharpeningImageFilter_swigregister(LaplacianSharpeningImageFilter)

def LaplacianSharpening(image1, useImageSpacing=True):
    r"""LaplacianSharpening(Image image1, bool useImageSpacing=True) -> Image"""
    return _SimpleITK.LaplacianSharpening(image1, useImageSpacing)
class LessEqualImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::LessEqualImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_LessEqualImageFilter

    def __init__(self):
        r"""__init__(LessEqualImageFilter self) -> LessEqualImageFilter"""
        _SimpleITK.LessEqualImageFilter_swiginit(self, _SimpleITK.new_LessEqualImageFilter())

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(LessEqualImageFilter self, uint8_t BackgroundValue)"""
        return _SimpleITK.LessEqualImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(LessEqualImageFilter self) -> uint8_t"""
        return _SimpleITK.LessEqualImageFilter_GetBackgroundValue(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(LessEqualImageFilter self, uint8_t ForegroundValue)"""
        return _SimpleITK.LessEqualImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(LessEqualImageFilter self) -> uint8_t"""
        return _SimpleITK.LessEqualImageFilter_GetForegroundValue(self)

    def GetName(self):
        r"""GetName(LessEqualImageFilter self) -> std::string"""
        return _SimpleITK.LessEqualImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(LessEqualImageFilter self) -> std::string"""
        return _SimpleITK.LessEqualImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(LessEqualImageFilter self, Image image1, Image image2) -> Image
        Execute(LessEqualImageFilter self, Image image1, double constant) -> Image
        Execute(LessEqualImageFilter self, double constant, Image image2) -> Image
        Execute(LessEqualImageFilter self, Image image1, double constant, uint8_t backgroundValue, uint8_t foregroundValue) -> Image
        Execute(LessEqualImageFilter self, double constant, Image image2, uint8_t backgroundValue, uint8_t foregroundValue) -> Image
        """
        return _SimpleITK.LessEqualImageFilter_Execute(self, *args)

# Register LessEqualImageFilter in _SimpleITK:
_SimpleITK.LessEqualImageFilter_swigregister(LessEqualImageFilter)

def LessEqual(*args):
    r"""
    LessEqual(Image image1, Image image2, uint8_t backgroundValue=0, uint8_t foregroundValue=1) -> Image
    LessEqual(Image image1, double constant, uint8_t backgroundValue=0, uint8_t foregroundValue=1) -> Image
    LessEqual(double constant, Image image2, uint8_t backgroundValue=0, uint8_t foregroundValue=1) -> Image
    """
    return _SimpleITK.LessEqual(*args)
class LessImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::LessImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_LessImageFilter

    def __init__(self):
        r"""__init__(LessImageFilter self) -> LessImageFilter"""
        _SimpleITK.LessImageFilter_swiginit(self, _SimpleITK.new_LessImageFilter())

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(LessImageFilter self, uint8_t BackgroundValue)"""
        return _SimpleITK.LessImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(LessImageFilter self) -> uint8_t"""
        return _SimpleITK.LessImageFilter_GetBackgroundValue(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(LessImageFilter self, uint8_t ForegroundValue)"""
        return _SimpleITK.LessImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(LessImageFilter self) -> uint8_t"""
        return _SimpleITK.LessImageFilter_GetForegroundValue(self)

    def GetName(self):
        r"""GetName(LessImageFilter self) -> std::string"""
        return _SimpleITK.LessImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(LessImageFilter self) -> std::string"""
        return _SimpleITK.LessImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(LessImageFilter self, Image image1, Image image2) -> Image
        Execute(LessImageFilter self, Image image1, double constant) -> Image
        Execute(LessImageFilter self, double constant, Image image2) -> Image
        Execute(LessImageFilter self, Image image1, double constant, uint8_t backgroundValue, uint8_t foregroundValue) -> Image
        Execute(LessImageFilter self, double constant, Image image2, uint8_t backgroundValue, uint8_t foregroundValue) -> Image
        """
        return _SimpleITK.LessImageFilter_Execute(self, *args)

# Register LessImageFilter in _SimpleITK:
_SimpleITK.LessImageFilter_swigregister(LessImageFilter)

def Less(*args):
    r"""
    Less(Image image1, Image image2, uint8_t backgroundValue=0, uint8_t foregroundValue=1) -> Image
    Less(Image image1, double constant, uint8_t backgroundValue=0, uint8_t foregroundValue=1) -> Image
    Less(double constant, Image image2, uint8_t backgroundValue=0, uint8_t foregroundValue=1) -> Image
    """
    return _SimpleITK.Less(*args)
class LevelSetMotionRegistrationFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::LevelSetMotionRegistrationFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_LevelSetMotionRegistrationFilter

    def __init__(self):
        r"""__init__(LevelSetMotionRegistrationFilter self) -> LevelSetMotionRegistrationFilter"""
        _SimpleITK.LevelSetMotionRegistrationFilter_swiginit(self, _SimpleITK.new_LevelSetMotionRegistrationFilter())

    def SetGradientSmoothingStandardDeviations(self, GradientSmoothingStandardDeviations):
        r"""SetGradientSmoothingStandardDeviations(LevelSetMotionRegistrationFilter self, double GradientSmoothingStandardDeviations)"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_SetGradientSmoothingStandardDeviations(self, GradientSmoothingStandardDeviations)

    def GetGradientSmoothingStandardDeviations(self):
        r"""GetGradientSmoothingStandardDeviations(LevelSetMotionRegistrationFilter self) -> double"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_GetGradientSmoothingStandardDeviations(self)

    def SetNumberOfIterations(self, NumberOfIterations):
        r"""SetNumberOfIterations(LevelSetMotionRegistrationFilter self, uint32_t NumberOfIterations)"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_SetNumberOfIterations(self, NumberOfIterations)

    def GetNumberOfIterations(self):
        r"""GetNumberOfIterations(LevelSetMotionRegistrationFilter self) -> uint32_t"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_GetNumberOfIterations(self)

    def SetMaximumRMSError(self, MaximumRMSError):
        r"""SetMaximumRMSError(LevelSetMotionRegistrationFilter self, double MaximumRMSError)"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_SetMaximumRMSError(self, MaximumRMSError)

    def GetMaximumRMSError(self):
        r"""GetMaximumRMSError(LevelSetMotionRegistrationFilter self) -> double"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_GetMaximumRMSError(self)

    def SetStandardDeviations(self, *args):
        r"""
        SetStandardDeviations(LevelSetMotionRegistrationFilter self, VectorDouble StandardDeviations)
        SetStandardDeviations(LevelSetMotionRegistrationFilter self, double value)
        """
        return _SimpleITK.LevelSetMotionRegistrationFilter_SetStandardDeviations(self, *args)

    def GetStandardDeviations(self):
        r"""GetStandardDeviations(LevelSetMotionRegistrationFilter self) -> VectorDouble"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_GetStandardDeviations(self)

    def SetSmoothDisplacementField(self, SmoothDisplacementField):
        r"""SetSmoothDisplacementField(LevelSetMotionRegistrationFilter self, bool SmoothDisplacementField)"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_SetSmoothDisplacementField(self, SmoothDisplacementField)

    def SmoothDisplacementFieldOn(self):
        r"""SmoothDisplacementFieldOn(LevelSetMotionRegistrationFilter self)"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_SmoothDisplacementFieldOn(self)

    def SmoothDisplacementFieldOff(self):
        r"""SmoothDisplacementFieldOff(LevelSetMotionRegistrationFilter self)"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_SmoothDisplacementFieldOff(self)

    def GetSmoothDisplacementField(self):
        r"""GetSmoothDisplacementField(LevelSetMotionRegistrationFilter self) -> bool"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_GetSmoothDisplacementField(self)

    def SetUpdateFieldStandardDeviations(self, *args):
        r"""
        SetUpdateFieldStandardDeviations(LevelSetMotionRegistrationFilter self, VectorDouble UpdateFieldStandardDeviations)
        SetUpdateFieldStandardDeviations(LevelSetMotionRegistrationFilter self, double value)
        """
        return _SimpleITK.LevelSetMotionRegistrationFilter_SetUpdateFieldStandardDeviations(self, *args)

    def GetUpdateFieldStandardDeviations(self):
        r"""GetUpdateFieldStandardDeviations(LevelSetMotionRegistrationFilter self) -> VectorDouble"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_GetUpdateFieldStandardDeviations(self)

    def SetSmoothUpdateField(self, SmoothUpdateField):
        r"""SetSmoothUpdateField(LevelSetMotionRegistrationFilter self, bool SmoothUpdateField)"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_SetSmoothUpdateField(self, SmoothUpdateField)

    def SmoothUpdateFieldOn(self):
        r"""SmoothUpdateFieldOn(LevelSetMotionRegistrationFilter self)"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_SmoothUpdateFieldOn(self)

    def SmoothUpdateFieldOff(self):
        r"""SmoothUpdateFieldOff(LevelSetMotionRegistrationFilter self)"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_SmoothUpdateFieldOff(self)

    def GetSmoothUpdateField(self):
        r"""GetSmoothUpdateField(LevelSetMotionRegistrationFilter self) -> bool"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_GetSmoothUpdateField(self)

    def SetMaximumKernelWidth(self, MaximumKernelWidth):
        r"""SetMaximumKernelWidth(LevelSetMotionRegistrationFilter self, unsigned int MaximumKernelWidth)"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_SetMaximumKernelWidth(self, MaximumKernelWidth)

    def GetMaximumKernelWidth(self):
        r"""GetMaximumKernelWidth(LevelSetMotionRegistrationFilter self) -> unsigned int"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_GetMaximumKernelWidth(self)

    def SetMaximumError(self, MaximumError):
        r"""SetMaximumError(LevelSetMotionRegistrationFilter self, double MaximumError)"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_SetMaximumError(self, MaximumError)

    def GetMaximumError(self):
        r"""GetMaximumError(LevelSetMotionRegistrationFilter self) -> double"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_GetMaximumError(self)

    def SetAlpha(self, Alpha):
        r"""SetAlpha(LevelSetMotionRegistrationFilter self, double Alpha)"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_SetAlpha(self, Alpha)

    def GetAlpha(self):
        r"""GetAlpha(LevelSetMotionRegistrationFilter self) -> double"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_GetAlpha(self)

    def SetIntensityDifferenceThreshold(self, IntensityDifferenceThreshold):
        r"""SetIntensityDifferenceThreshold(LevelSetMotionRegistrationFilter self, double IntensityDifferenceThreshold)"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_SetIntensityDifferenceThreshold(self, IntensityDifferenceThreshold)

    def GetIntensityDifferenceThreshold(self):
        r"""GetIntensityDifferenceThreshold(LevelSetMotionRegistrationFilter self) -> double"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_GetIntensityDifferenceThreshold(self)

    def SetGradientMagnitudeThreshold(self, GradientMagnitudeThreshold):
        r"""SetGradientMagnitudeThreshold(LevelSetMotionRegistrationFilter self, double GradientMagnitudeThreshold)"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_SetGradientMagnitudeThreshold(self, GradientMagnitudeThreshold)

    def GetGradientMagnitudeThreshold(self):
        r"""GetGradientMagnitudeThreshold(LevelSetMotionRegistrationFilter self) -> double"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_GetGradientMagnitudeThreshold(self)

    def SetUseImageSpacing(self, UseImageSpacing):
        r"""SetUseImageSpacing(LevelSetMotionRegistrationFilter self, bool UseImageSpacing)"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_SetUseImageSpacing(self, UseImageSpacing)

    def UseImageSpacingOn(self):
        r"""UseImageSpacingOn(LevelSetMotionRegistrationFilter self)"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_UseImageSpacingOn(self)

    def UseImageSpacingOff(self):
        r"""UseImageSpacingOff(LevelSetMotionRegistrationFilter self)"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_UseImageSpacingOff(self)

    def GetUseImageSpacing(self):
        r"""GetUseImageSpacing(LevelSetMotionRegistrationFilter self) -> bool"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_GetUseImageSpacing(self)

    def GetElapsedIterations(self):
        r"""GetElapsedIterations(LevelSetMotionRegistrationFilter self) -> uint32_t"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_GetElapsedIterations(self)

    def GetRMSChange(self):
        r"""GetRMSChange(LevelSetMotionRegistrationFilter self) -> double"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_GetRMSChange(self)

    def GetMetric(self):
        r"""GetMetric(LevelSetMotionRegistrationFilter self) -> double"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_GetMetric(self)

    def GetName(self):
        r"""GetName(LevelSetMotionRegistrationFilter self) -> std::string"""
        return _SimpleITK.LevelSetMotionRegistrationFilter_GetName(self)

    def __str__(self):
        r"""__str__(LevelSetMotionRegistrationFilter self) -> std::string"""
        return _SimpleITK.LevelSetMotionRegistrationFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(LevelSetMotionRegistrationFilter self, Image fixedImage, Image movingImage, Image initialDisplacementField) -> Image
        Execute(LevelSetMotionRegistrationFilter self, Image fixedImage, Image movingImage) -> Image
        """
        return _SimpleITK.LevelSetMotionRegistrationFilter_Execute(self, *args)

# Register LevelSetMotionRegistrationFilter in _SimpleITK:
_SimpleITK.LevelSetMotionRegistrationFilter_swigregister(LevelSetMotionRegistrationFilter)
class LiThresholdImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::LiThresholdImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_LiThresholdImageFilter

    def __init__(self):
        r"""__init__(LiThresholdImageFilter self) -> LiThresholdImageFilter"""
        _SimpleITK.LiThresholdImageFilter_swiginit(self, _SimpleITK.new_LiThresholdImageFilter())

    def SetInsideValue(self, InsideValue):
        r"""SetInsideValue(LiThresholdImageFilter self, uint8_t InsideValue)"""
        return _SimpleITK.LiThresholdImageFilter_SetInsideValue(self, InsideValue)

    def GetInsideValue(self):
        r"""GetInsideValue(LiThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.LiThresholdImageFilter_GetInsideValue(self)

    def SetOutsideValue(self, OutsideValue):
        r"""SetOutsideValue(LiThresholdImageFilter self, uint8_t OutsideValue)"""
        return _SimpleITK.LiThresholdImageFilter_SetOutsideValue(self, OutsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(LiThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.LiThresholdImageFilter_GetOutsideValue(self)

    def SetNumberOfHistogramBins(self, NumberOfHistogramBins):
        r"""SetNumberOfHistogramBins(LiThresholdImageFilter self, uint32_t NumberOfHistogramBins)"""
        return _SimpleITK.LiThresholdImageFilter_SetNumberOfHistogramBins(self, NumberOfHistogramBins)

    def GetNumberOfHistogramBins(self):
        r"""GetNumberOfHistogramBins(LiThresholdImageFilter self) -> uint32_t"""
        return _SimpleITK.LiThresholdImageFilter_GetNumberOfHistogramBins(self)

    def SetMaskOutput(self, MaskOutput):
        r"""SetMaskOutput(LiThresholdImageFilter self, bool MaskOutput)"""
        return _SimpleITK.LiThresholdImageFilter_SetMaskOutput(self, MaskOutput)

    def MaskOutputOn(self):
        r"""MaskOutputOn(LiThresholdImageFilter self)"""
        return _SimpleITK.LiThresholdImageFilter_MaskOutputOn(self)

    def MaskOutputOff(self):
        r"""MaskOutputOff(LiThresholdImageFilter self)"""
        return _SimpleITK.LiThresholdImageFilter_MaskOutputOff(self)

    def GetMaskOutput(self):
        r"""GetMaskOutput(LiThresholdImageFilter self) -> bool"""
        return _SimpleITK.LiThresholdImageFilter_GetMaskOutput(self)

    def SetMaskValue(self, MaskValue):
        r"""SetMaskValue(LiThresholdImageFilter self, uint8_t MaskValue)"""
        return _SimpleITK.LiThresholdImageFilter_SetMaskValue(self, MaskValue)

    def GetMaskValue(self):
        r"""GetMaskValue(LiThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.LiThresholdImageFilter_GetMaskValue(self)

    def GetThreshold(self):
        r"""GetThreshold(LiThresholdImageFilter self) -> double"""
        return _SimpleITK.LiThresholdImageFilter_GetThreshold(self)

    def GetName(self):
        r"""GetName(LiThresholdImageFilter self) -> std::string"""
        return _SimpleITK.LiThresholdImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(LiThresholdImageFilter self) -> std::string"""
        return _SimpleITK.LiThresholdImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(LiThresholdImageFilter self, Image image, Image maskImage) -> Image
        Execute(LiThresholdImageFilter self, Image image) -> Image
        """
        return _SimpleITK.LiThresholdImageFilter_Execute(self, *args)

# Register LiThresholdImageFilter in _SimpleITK:
_SimpleITK.LiThresholdImageFilter_swigregister(LiThresholdImageFilter)

def LiThreshold(*args):
    r"""
    LiThreshold(Image image, Image maskImage, uint8_t insideValue=1, uint8_t outsideValue=0, uint32_t numberOfHistogramBins=256, bool maskOutput=True, uint8_t maskValue=255) -> Image
    LiThreshold(Image image, uint8_t insideValue=1, uint8_t outsideValue=0, uint32_t numberOfHistogramBins=256, bool maskOutput=True, uint8_t maskValue=255) -> Image
    """
    return _SimpleITK.LiThreshold(*args)
class Log10ImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::Log10ImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_Log10ImageFilter

    def __init__(self):
        r"""__init__(Log10ImageFilter self) -> Log10ImageFilter"""
        _SimpleITK.Log10ImageFilter_swiginit(self, _SimpleITK.new_Log10ImageFilter())

    def GetName(self):
        r"""GetName(Log10ImageFilter self) -> std::string"""
        return _SimpleITK.Log10ImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(Log10ImageFilter self) -> std::string"""
        return _SimpleITK.Log10ImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(Log10ImageFilter self, Image image1) -> Image"""
        return _SimpleITK.Log10ImageFilter_Execute(self, image1)

# Register Log10ImageFilter in _SimpleITK:
_SimpleITK.Log10ImageFilter_swigregister(Log10ImageFilter)

def Log10(image1):
    r"""Log10(Image image1) -> Image"""
    return _SimpleITK.Log10(image1)
class LogImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::LogImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_LogImageFilter

    def __init__(self):
        r"""__init__(LogImageFilter self) -> LogImageFilter"""
        _SimpleITK.LogImageFilter_swiginit(self, _SimpleITK.new_LogImageFilter())

    def GetName(self):
        r"""GetName(LogImageFilter self) -> std::string"""
        return _SimpleITK.LogImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(LogImageFilter self) -> std::string"""
        return _SimpleITK.LogImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(LogImageFilter self, Image image1) -> Image"""
        return _SimpleITK.LogImageFilter_Execute(self, image1)

# Register LogImageFilter in _SimpleITK:
_SimpleITK.LogImageFilter_swigregister(LogImageFilter)

def Log(image1):
    r"""Log(Image image1) -> Image"""
    return _SimpleITK.Log(image1)
class MagnitudeAndPhaseToComplexImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::MagnitudeAndPhaseToComplexImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_MagnitudeAndPhaseToComplexImageFilter

    def __init__(self):
        r"""__init__(MagnitudeAndPhaseToComplexImageFilter self) -> MagnitudeAndPhaseToComplexImageFilter"""
        _SimpleITK.MagnitudeAndPhaseToComplexImageFilter_swiginit(self, _SimpleITK.new_MagnitudeAndPhaseToComplexImageFilter())

    def GetName(self):
        r"""GetName(MagnitudeAndPhaseToComplexImageFilter self) -> std::string"""
        return _SimpleITK.MagnitudeAndPhaseToComplexImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(MagnitudeAndPhaseToComplexImageFilter self) -> std::string"""
        return _SimpleITK.MagnitudeAndPhaseToComplexImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(MagnitudeAndPhaseToComplexImageFilter self, Image image1, Image image2) -> Image
        Execute(MagnitudeAndPhaseToComplexImageFilter self, Image image1, double constant) -> Image
        Execute(MagnitudeAndPhaseToComplexImageFilter self, double constant, Image image2) -> Image
        """
        return _SimpleITK.MagnitudeAndPhaseToComplexImageFilter_Execute(self, *args)

# Register MagnitudeAndPhaseToComplexImageFilter in _SimpleITK:
_SimpleITK.MagnitudeAndPhaseToComplexImageFilter_swigregister(MagnitudeAndPhaseToComplexImageFilter)

def MagnitudeAndPhaseToComplex(*args):
    r"""
    MagnitudeAndPhaseToComplex(Image image1, Image image2) -> Image
    MagnitudeAndPhaseToComplex(Image image1, double constant) -> Image
    MagnitudeAndPhaseToComplex(double constant, Image image2) -> Image
    """
    return _SimpleITK.MagnitudeAndPhaseToComplex(*args)
class MaskImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::MaskImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_MaskImageFilter

    def __init__(self):
        r"""__init__(MaskImageFilter self) -> MaskImageFilter"""
        _SimpleITK.MaskImageFilter_swiginit(self, _SimpleITK.new_MaskImageFilter())

    def SetOutsideValue(self, OutsideValue):
        r"""SetOutsideValue(MaskImageFilter self, double OutsideValue)"""
        return _SimpleITK.MaskImageFilter_SetOutsideValue(self, OutsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(MaskImageFilter self) -> double"""
        return _SimpleITK.MaskImageFilter_GetOutsideValue(self)

    def SetMaskingValue(self, MaskingValue):
        r"""SetMaskingValue(MaskImageFilter self, double MaskingValue)"""
        return _SimpleITK.MaskImageFilter_SetMaskingValue(self, MaskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(MaskImageFilter self) -> double"""
        return _SimpleITK.MaskImageFilter_GetMaskingValue(self)

    def GetName(self):
        r"""GetName(MaskImageFilter self) -> std::string"""
        return _SimpleITK.MaskImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(MaskImageFilter self) -> std::string"""
        return _SimpleITK.MaskImageFilter___str__(self)

    def Execute(self, image, maskImage):
        r"""Execute(MaskImageFilter self, Image image, Image maskImage) -> Image"""
        return _SimpleITK.MaskImageFilter_Execute(self, image, maskImage)

# Register MaskImageFilter in _SimpleITK:
_SimpleITK.MaskImageFilter_swigregister(MaskImageFilter)

def Mask(image, maskImage, outsideValue=0, maskingValue=0):
    r"""Mask(Image image, Image maskImage, double outsideValue=0, double maskingValue=0) -> Image"""
    return _SimpleITK.Mask(image, maskImage, outsideValue, maskingValue)
class MaskNegatedImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::MaskNegatedImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_MaskNegatedImageFilter

    def __init__(self):
        r"""__init__(MaskNegatedImageFilter self) -> MaskNegatedImageFilter"""
        _SimpleITK.MaskNegatedImageFilter_swiginit(self, _SimpleITK.new_MaskNegatedImageFilter())

    def SetOutsideValue(self, OutsideValue):
        r"""SetOutsideValue(MaskNegatedImageFilter self, double OutsideValue)"""
        return _SimpleITK.MaskNegatedImageFilter_SetOutsideValue(self, OutsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(MaskNegatedImageFilter self) -> double"""
        return _SimpleITK.MaskNegatedImageFilter_GetOutsideValue(self)

    def SetMaskingValue(self, MaskingValue):
        r"""SetMaskingValue(MaskNegatedImageFilter self, double MaskingValue)"""
        return _SimpleITK.MaskNegatedImageFilter_SetMaskingValue(self, MaskingValue)

    def GetMaskingValue(self):
        r"""GetMaskingValue(MaskNegatedImageFilter self) -> double"""
        return _SimpleITK.MaskNegatedImageFilter_GetMaskingValue(self)

    def GetName(self):
        r"""GetName(MaskNegatedImageFilter self) -> std::string"""
        return _SimpleITK.MaskNegatedImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(MaskNegatedImageFilter self) -> std::string"""
        return _SimpleITK.MaskNegatedImageFilter___str__(self)

    def Execute(self, image, maskImage):
        r"""Execute(MaskNegatedImageFilter self, Image image, Image maskImage) -> Image"""
        return _SimpleITK.MaskNegatedImageFilter_Execute(self, image, maskImage)

# Register MaskNegatedImageFilter in _SimpleITK:
_SimpleITK.MaskNegatedImageFilter_swigregister(MaskNegatedImageFilter)

def MaskNegated(image, maskImage, outsideValue=0, maskingValue=0):
    r"""MaskNegated(Image image, Image maskImage, double outsideValue=0, double maskingValue=0) -> Image"""
    return _SimpleITK.MaskNegated(image, maskImage, outsideValue, maskingValue)
class MaskedAssignImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::MaskedAssignImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_MaskedAssignImageFilter

    def __init__(self):
        r"""__init__(MaskedAssignImageFilter self) -> MaskedAssignImageFilter"""
        _SimpleITK.MaskedAssignImageFilter_swiginit(self, _SimpleITK.new_MaskedAssignImageFilter())

    def SetAssignConstant(self, AssignConstant):
        r"""SetAssignConstant(MaskedAssignImageFilter self, double AssignConstant)"""
        return _SimpleITK.MaskedAssignImageFilter_SetAssignConstant(self, AssignConstant)

    def GetAssignConstant(self):
        r"""GetAssignConstant(MaskedAssignImageFilter self) -> double"""
        return _SimpleITK.MaskedAssignImageFilter_GetAssignConstant(self)

    def GetName(self):
        r"""GetName(MaskedAssignImageFilter self) -> std::string"""
        return _SimpleITK.MaskedAssignImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(MaskedAssignImageFilter self) -> std::string"""
        return _SimpleITK.MaskedAssignImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(MaskedAssignImageFilter self, Image image, Image maskImage, Image assignImage) -> Image
        Execute(MaskedAssignImageFilter self, Image image, Image maskImage) -> Image
        """
        return _SimpleITK.MaskedAssignImageFilter_Execute(self, *args)

# Register MaskedAssignImageFilter in _SimpleITK:
_SimpleITK.MaskedAssignImageFilter_swigregister(MaskedAssignImageFilter)

def MaskedAssign(*args):
    r"""
    MaskedAssign(Image image, Image maskImage, Image assignImage, double assignConstant=0) -> Image
    MaskedAssign(Image image, Image maskImage, double assignConstant=0) -> Image
    """
    return _SimpleITK.MaskedAssign(*args)
class MaskedFFTNormalizedCorrelationImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::MaskedFFTNormalizedCorrelationImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_MaskedFFTNormalizedCorrelationImageFilter

    def __init__(self):
        r"""__init__(MaskedFFTNormalizedCorrelationImageFilter self) -> MaskedFFTNormalizedCorrelationImageFilter"""
        _SimpleITK.MaskedFFTNormalizedCorrelationImageFilter_swiginit(self, _SimpleITK.new_MaskedFFTNormalizedCorrelationImageFilter())

    def SetRequiredNumberOfOverlappingPixels(self, RequiredNumberOfOverlappingPixels):
        r"""SetRequiredNumberOfOverlappingPixels(MaskedFFTNormalizedCorrelationImageFilter self, uint64_t RequiredNumberOfOverlappingPixels)"""
        return _SimpleITK.MaskedFFTNormalizedCorrelationImageFilter_SetRequiredNumberOfOverlappingPixels(self, RequiredNumberOfOverlappingPixels)

    def GetRequiredNumberOfOverlappingPixels(self):
        r"""GetRequiredNumberOfOverlappingPixels(MaskedFFTNormalizedCorrelationImageFilter self) -> uint64_t"""
        return _SimpleITK.MaskedFFTNormalizedCorrelationImageFilter_GetRequiredNumberOfOverlappingPixels(self)

    def SetRequiredFractionOfOverlappingPixels(self, RequiredFractionOfOverlappingPixels):
        r"""SetRequiredFractionOfOverlappingPixels(MaskedFFTNormalizedCorrelationImageFilter self, float RequiredFractionOfOverlappingPixels)"""
        return _SimpleITK.MaskedFFTNormalizedCorrelationImageFilter_SetRequiredFractionOfOverlappingPixels(self, RequiredFractionOfOverlappingPixels)

    def GetRequiredFractionOfOverlappingPixels(self):
        r"""GetRequiredFractionOfOverlappingPixels(MaskedFFTNormalizedCorrelationImageFilter self) -> float"""
        return _SimpleITK.MaskedFFTNormalizedCorrelationImageFilter_GetRequiredFractionOfOverlappingPixels(self)

    def GetName(self):
        r"""GetName(MaskedFFTNormalizedCorrelationImageFilter self) -> std::string"""
        return _SimpleITK.MaskedFFTNormalizedCorrelationImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(MaskedFFTNormalizedCorrelationImageFilter self) -> std::string"""
        return _SimpleITK.MaskedFFTNormalizedCorrelationImageFilter___str__(self)

    def Execute(self, fixedImage, movingImage, fixedImageMask, movingImageMask):
        r"""Execute(MaskedFFTNormalizedCorrelationImageFilter self, Image fixedImage, Image movingImage, Image fixedImageMask, Image movingImageMask) -> Image"""
        return _SimpleITK.MaskedFFTNormalizedCorrelationImageFilter_Execute(self, fixedImage, movingImage, fixedImageMask, movingImageMask)

# Register MaskedFFTNormalizedCorrelationImageFilter in _SimpleITK:
_SimpleITK.MaskedFFTNormalizedCorrelationImageFilter_swigregister(MaskedFFTNormalizedCorrelationImageFilter)

def MaskedFFTNormalizedCorrelation(fixedImage, movingImage, fixedImageMask, movingImageMask, requiredNumberOfOverlappingPixels=0, requiredFractionOfOverlappingPixels=0.0):
    r"""MaskedFFTNormalizedCorrelation(Image fixedImage, Image movingImage, Image fixedImageMask, Image movingImageMask, uint64_t requiredNumberOfOverlappingPixels=0, float requiredFractionOfOverlappingPixels=0.0) -> Image"""
    return _SimpleITK.MaskedFFTNormalizedCorrelation(fixedImage, movingImage, fixedImageMask, movingImageMask, requiredNumberOfOverlappingPixels, requiredFractionOfOverlappingPixels)
class MaximumEntropyThresholdImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::MaximumEntropyThresholdImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_MaximumEntropyThresholdImageFilter

    def __init__(self):
        r"""__init__(MaximumEntropyThresholdImageFilter self) -> MaximumEntropyThresholdImageFilter"""
        _SimpleITK.MaximumEntropyThresholdImageFilter_swiginit(self, _SimpleITK.new_MaximumEntropyThresholdImageFilter())

    def SetInsideValue(self, InsideValue):
        r"""SetInsideValue(MaximumEntropyThresholdImageFilter self, uint8_t InsideValue)"""
        return _SimpleITK.MaximumEntropyThresholdImageFilter_SetInsideValue(self, InsideValue)

    def GetInsideValue(self):
        r"""GetInsideValue(MaximumEntropyThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.MaximumEntropyThresholdImageFilter_GetInsideValue(self)

    def SetOutsideValue(self, OutsideValue):
        r"""SetOutsideValue(MaximumEntropyThresholdImageFilter self, uint8_t OutsideValue)"""
        return _SimpleITK.MaximumEntropyThresholdImageFilter_SetOutsideValue(self, OutsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(MaximumEntropyThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.MaximumEntropyThresholdImageFilter_GetOutsideValue(self)

    def SetNumberOfHistogramBins(self, NumberOfHistogramBins):
        r"""SetNumberOfHistogramBins(MaximumEntropyThresholdImageFilter self, uint32_t NumberOfHistogramBins)"""
        return _SimpleITK.MaximumEntropyThresholdImageFilter_SetNumberOfHistogramBins(self, NumberOfHistogramBins)

    def GetNumberOfHistogramBins(self):
        r"""GetNumberOfHistogramBins(MaximumEntropyThresholdImageFilter self) -> uint32_t"""
        return _SimpleITK.MaximumEntropyThresholdImageFilter_GetNumberOfHistogramBins(self)

    def SetMaskOutput(self, MaskOutput):
        r"""SetMaskOutput(MaximumEntropyThresholdImageFilter self, bool MaskOutput)"""
        return _SimpleITK.MaximumEntropyThresholdImageFilter_SetMaskOutput(self, MaskOutput)

    def MaskOutputOn(self):
        r"""MaskOutputOn(MaximumEntropyThresholdImageFilter self)"""
        return _SimpleITK.MaximumEntropyThresholdImageFilter_MaskOutputOn(self)

    def MaskOutputOff(self):
        r"""MaskOutputOff(MaximumEntropyThresholdImageFilter self)"""
        return _SimpleITK.MaximumEntropyThresholdImageFilter_MaskOutputOff(self)

    def GetMaskOutput(self):
        r"""GetMaskOutput(MaximumEntropyThresholdImageFilter self) -> bool"""
        return _SimpleITK.MaximumEntropyThresholdImageFilter_GetMaskOutput(self)

    def SetMaskValue(self, MaskValue):
        r"""SetMaskValue(MaximumEntropyThresholdImageFilter self, uint8_t MaskValue)"""
        return _SimpleITK.MaximumEntropyThresholdImageFilter_SetMaskValue(self, MaskValue)

    def GetMaskValue(self):
        r"""GetMaskValue(MaximumEntropyThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.MaximumEntropyThresholdImageFilter_GetMaskValue(self)

    def GetThreshold(self):
        r"""GetThreshold(MaximumEntropyThresholdImageFilter self) -> double"""
        return _SimpleITK.MaximumEntropyThresholdImageFilter_GetThreshold(self)

    def GetName(self):
        r"""GetName(MaximumEntropyThresholdImageFilter self) -> std::string"""
        return _SimpleITK.MaximumEntropyThresholdImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(MaximumEntropyThresholdImageFilter self) -> std::string"""
        return _SimpleITK.MaximumEntropyThresholdImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(MaximumEntropyThresholdImageFilter self, Image image, Image maskImage) -> Image
        Execute(MaximumEntropyThresholdImageFilter self, Image image) -> Image
        """
        return _SimpleITK.MaximumEntropyThresholdImageFilter_Execute(self, *args)

# Register MaximumEntropyThresholdImageFilter in _SimpleITK:
_SimpleITK.MaximumEntropyThresholdImageFilter_swigregister(MaximumEntropyThresholdImageFilter)

def MaximumEntropyThreshold(*args):
    r"""
    MaximumEntropyThreshold(Image image, Image maskImage, uint8_t insideValue=1, uint8_t outsideValue=0, uint32_t numberOfHistogramBins=256, bool maskOutput=True, uint8_t maskValue=255) -> Image
    MaximumEntropyThreshold(Image image, uint8_t insideValue=1, uint8_t outsideValue=0, uint32_t numberOfHistogramBins=256, bool maskOutput=True, uint8_t maskValue=255) -> Image
    """
    return _SimpleITK.MaximumEntropyThreshold(*args)
class MaximumImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::MaximumImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_MaximumImageFilter

    def __init__(self):
        r"""__init__(MaximumImageFilter self) -> MaximumImageFilter"""
        _SimpleITK.MaximumImageFilter_swiginit(self, _SimpleITK.new_MaximumImageFilter())

    def GetName(self):
        r"""GetName(MaximumImageFilter self) -> std::string"""
        return _SimpleITK.MaximumImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(MaximumImageFilter self) -> std::string"""
        return _SimpleITK.MaximumImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(MaximumImageFilter self, Image image1, Image image2) -> Image
        Execute(MaximumImageFilter self, Image image1, double constant) -> Image
        Execute(MaximumImageFilter self, double constant, Image image2) -> Image
        """
        return _SimpleITK.MaximumImageFilter_Execute(self, *args)

# Register MaximumImageFilter in _SimpleITK:
_SimpleITK.MaximumImageFilter_swigregister(MaximumImageFilter)

def Maximum(*args):
    r"""
    Maximum(Image image1, Image image2) -> Image
    Maximum(Image image1, double constant) -> Image
    Maximum(double constant, Image image2) -> Image
    """
    return _SimpleITK.Maximum(*args)
class MaximumProjectionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::MaximumProjectionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_MaximumProjectionImageFilter

    def __init__(self):
        r"""__init__(MaximumProjectionImageFilter self) -> MaximumProjectionImageFilter"""
        _SimpleITK.MaximumProjectionImageFilter_swiginit(self, _SimpleITK.new_MaximumProjectionImageFilter())

    def SetProjectionDimension(self, ProjectionDimension):
        r"""SetProjectionDimension(MaximumProjectionImageFilter self, unsigned int ProjectionDimension)"""
        return _SimpleITK.MaximumProjectionImageFilter_SetProjectionDimension(self, ProjectionDimension)

    def GetProjectionDimension(self):
        r"""GetProjectionDimension(MaximumProjectionImageFilter self) -> unsigned int"""
        return _SimpleITK.MaximumProjectionImageFilter_GetProjectionDimension(self)

    def GetName(self):
        r"""GetName(MaximumProjectionImageFilter self) -> std::string"""
        return _SimpleITK.MaximumProjectionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(MaximumProjectionImageFilter self) -> std::string"""
        return _SimpleITK.MaximumProjectionImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(MaximumProjectionImageFilter self, Image image1) -> Image"""
        return _SimpleITK.MaximumProjectionImageFilter_Execute(self, image1)

# Register MaximumProjectionImageFilter in _SimpleITK:
_SimpleITK.MaximumProjectionImageFilter_swigregister(MaximumProjectionImageFilter)

def MaximumProjection(image1, projectionDimension=0):
    r"""MaximumProjection(Image image1, unsigned int projectionDimension=0) -> Image"""
    return _SimpleITK.MaximumProjection(image1, projectionDimension)
class MeanImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::MeanImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_MeanImageFilter

    def __init__(self):
        r"""__init__(MeanImageFilter self) -> MeanImageFilter"""
        _SimpleITK.MeanImageFilter_swiginit(self, _SimpleITK.new_MeanImageFilter())

    def SetRadius(self, *args):
        r"""
        SetRadius(MeanImageFilter self, VectorUInt32 Radius)
        SetRadius(MeanImageFilter self, unsigned int value)
        """
        return _SimpleITK.MeanImageFilter_SetRadius(self, *args)

    def GetRadius(self):
        r"""GetRadius(MeanImageFilter self) -> VectorUInt32"""
        return _SimpleITK.MeanImageFilter_GetRadius(self)

    def GetName(self):
        r"""GetName(MeanImageFilter self) -> std::string"""
        return _SimpleITK.MeanImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(MeanImageFilter self) -> std::string"""
        return _SimpleITK.MeanImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(MeanImageFilter self, Image image1) -> Image"""
        return _SimpleITK.MeanImageFilter_Execute(self, image1)

# Register MeanImageFilter in _SimpleITK:
_SimpleITK.MeanImageFilter_swigregister(MeanImageFilter)

def Mean(*args, **kwargs):
    r"""Mean(Image image1, VectorUInt32 radius=std::vector< unsigned int >(3, 1)) -> Image"""
    return _SimpleITK.Mean(*args, **kwargs)
class MeanProjectionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::MeanProjectionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_MeanProjectionImageFilter

    def __init__(self):
        r"""__init__(MeanProjectionImageFilter self) -> MeanProjectionImageFilter"""
        _SimpleITK.MeanProjectionImageFilter_swiginit(self, _SimpleITK.new_MeanProjectionImageFilter())

    def SetProjectionDimension(self, ProjectionDimension):
        r"""SetProjectionDimension(MeanProjectionImageFilter self, unsigned int ProjectionDimension)"""
        return _SimpleITK.MeanProjectionImageFilter_SetProjectionDimension(self, ProjectionDimension)

    def GetProjectionDimension(self):
        r"""GetProjectionDimension(MeanProjectionImageFilter self) -> unsigned int"""
        return _SimpleITK.MeanProjectionImageFilter_GetProjectionDimension(self)

    def GetName(self):
        r"""GetName(MeanProjectionImageFilter self) -> std::string"""
        return _SimpleITK.MeanProjectionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(MeanProjectionImageFilter self) -> std::string"""
        return _SimpleITK.MeanProjectionImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(MeanProjectionImageFilter self, Image image1) -> Image"""
        return _SimpleITK.MeanProjectionImageFilter_Execute(self, image1)

# Register MeanProjectionImageFilter in _SimpleITK:
_SimpleITK.MeanProjectionImageFilter_swigregister(MeanProjectionImageFilter)

def MeanProjection(image1, projectionDimension=0):
    r"""MeanProjection(Image image1, unsigned int projectionDimension=0) -> Image"""
    return _SimpleITK.MeanProjection(image1, projectionDimension)
class MedianImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::MedianImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_MedianImageFilter

    def __init__(self):
        r"""__init__(MedianImageFilter self) -> MedianImageFilter"""
        _SimpleITK.MedianImageFilter_swiginit(self, _SimpleITK.new_MedianImageFilter())

    def SetRadius(self, *args):
        r"""
        SetRadius(MedianImageFilter self, VectorUInt32 Radius)
        SetRadius(MedianImageFilter self, unsigned int value)
        """
        return _SimpleITK.MedianImageFilter_SetRadius(self, *args)

    def GetRadius(self):
        r"""GetRadius(MedianImageFilter self) -> VectorUInt32"""
        return _SimpleITK.MedianImageFilter_GetRadius(self)

    def GetName(self):
        r"""GetName(MedianImageFilter self) -> std::string"""
        return _SimpleITK.MedianImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(MedianImageFilter self) -> std::string"""
        return _SimpleITK.MedianImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(MedianImageFilter self, Image image1) -> Image"""
        return _SimpleITK.MedianImageFilter_Execute(self, image1)

# Register MedianImageFilter in _SimpleITK:
_SimpleITK.MedianImageFilter_swigregister(MedianImageFilter)

def Median(*args, **kwargs):
    r"""Median(Image image1, VectorUInt32 radius=std::vector< unsigned int >(3, 1)) -> Image"""
    return _SimpleITK.Median(*args, **kwargs)
class MedianProjectionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::MedianProjectionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_MedianProjectionImageFilter

    def __init__(self):
        r"""__init__(MedianProjectionImageFilter self) -> MedianProjectionImageFilter"""
        _SimpleITK.MedianProjectionImageFilter_swiginit(self, _SimpleITK.new_MedianProjectionImageFilter())

    def SetProjectionDimension(self, ProjectionDimension):
        r"""SetProjectionDimension(MedianProjectionImageFilter self, unsigned int ProjectionDimension)"""
        return _SimpleITK.MedianProjectionImageFilter_SetProjectionDimension(self, ProjectionDimension)

    def GetProjectionDimension(self):
        r"""GetProjectionDimension(MedianProjectionImageFilter self) -> unsigned int"""
        return _SimpleITK.MedianProjectionImageFilter_GetProjectionDimension(self)

    def GetName(self):
        r"""GetName(MedianProjectionImageFilter self) -> std::string"""
        return _SimpleITK.MedianProjectionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(MedianProjectionImageFilter self) -> std::string"""
        return _SimpleITK.MedianProjectionImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(MedianProjectionImageFilter self, Image image1) -> Image"""
        return _SimpleITK.MedianProjectionImageFilter_Execute(self, image1)

# Register MedianProjectionImageFilter in _SimpleITK:
_SimpleITK.MedianProjectionImageFilter_swigregister(MedianProjectionImageFilter)

def MedianProjection(image1, projectionDimension=0):
    r"""MedianProjection(Image image1, unsigned int projectionDimension=0) -> Image"""
    return _SimpleITK.MedianProjection(image1, projectionDimension)
class MergeLabelMapFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::MergeLabelMapFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_MergeLabelMapFilter

    def __init__(self):
        r"""__init__(MergeLabelMapFilter self) -> MergeLabelMapFilter"""
        _SimpleITK.MergeLabelMapFilter_swiginit(self, _SimpleITK.new_MergeLabelMapFilter())
    Keep = _SimpleITK.MergeLabelMapFilter_Keep
    
    Aggregate = _SimpleITK.MergeLabelMapFilter_Aggregate
    
    Pack = _SimpleITK.MergeLabelMapFilter_Pack
    
    Strict = _SimpleITK.MergeLabelMapFilter_Strict
    

    def SetMethod(self, Method):
        r"""SetMethod(MergeLabelMapFilter self, slicer_itk::simple::MergeLabelMapFilter::MethodType Method)"""
        return _SimpleITK.MergeLabelMapFilter_SetMethod(self, Method)

    def GetMethod(self):
        r"""GetMethod(MergeLabelMapFilter self) -> slicer_itk::simple::MergeLabelMapFilter::MethodType"""
        return _SimpleITK.MergeLabelMapFilter_GetMethod(self)

    def GetName(self):
        r"""GetName(MergeLabelMapFilter self) -> std::string"""
        return _SimpleITK.MergeLabelMapFilter_GetName(self)

    def __str__(self):
        r"""__str__(MergeLabelMapFilter self) -> std::string"""
        return _SimpleITK.MergeLabelMapFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(MergeLabelMapFilter self, VectorOfImage images) -> Image
        Execute(MergeLabelMapFilter self, Image image1) -> Image
        Execute(MergeLabelMapFilter self, Image image1, Image image2) -> Image
        Execute(MergeLabelMapFilter self, Image image1, Image image2, Image image3) -> Image
        Execute(MergeLabelMapFilter self, Image image1, Image image2, Image image3, Image image4) -> Image
        Execute(MergeLabelMapFilter self, Image image1, Image image2, Image image3, Image image4, Image image5) -> Image
        """
        return _SimpleITK.MergeLabelMapFilter_Execute(self, *args)

# Register MergeLabelMapFilter in _SimpleITK:
_SimpleITK.MergeLabelMapFilter_swigregister(MergeLabelMapFilter)

def MergeLabelMap(*args):
    r"""
    MergeLabelMap(VectorOfImage images, slicer_itk::simple::MergeLabelMapFilter::MethodType method=Keep) -> Image
    MergeLabelMap(Image image1, slicer_itk::simple::MergeLabelMapFilter::MethodType method=Keep) -> Image
    MergeLabelMap(Image image1, Image image2, slicer_itk::simple::MergeLabelMapFilter::MethodType method=Keep) -> Image
    MergeLabelMap(Image image1, Image image2, Image image3, slicer_itk::simple::MergeLabelMapFilter::MethodType method=Keep) -> Image
    MergeLabelMap(Image image1, Image image2, Image image3, Image image4, slicer_itk::simple::MergeLabelMapFilter::MethodType method=Keep) -> Image
    MergeLabelMap(Image image1, Image image2, Image image3, Image image4, Image image5, slicer_itk::simple::MergeLabelMapFilter::MethodType method=Keep) -> Image
    """
    return _SimpleITK.MergeLabelMap(*args)
class MinMaxCurvatureFlowImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::MinMaxCurvatureFlowImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_MinMaxCurvatureFlowImageFilter

    def __init__(self):
        r"""__init__(MinMaxCurvatureFlowImageFilter self) -> MinMaxCurvatureFlowImageFilter"""
        _SimpleITK.MinMaxCurvatureFlowImageFilter_swiginit(self, _SimpleITK.new_MinMaxCurvatureFlowImageFilter())

    def SetTimeStep(self, TimeStep):
        r"""SetTimeStep(MinMaxCurvatureFlowImageFilter self, double TimeStep)"""
        return _SimpleITK.MinMaxCurvatureFlowImageFilter_SetTimeStep(self, TimeStep)

    def GetTimeStep(self):
        r"""GetTimeStep(MinMaxCurvatureFlowImageFilter self) -> double"""
        return _SimpleITK.MinMaxCurvatureFlowImageFilter_GetTimeStep(self)

    def SetNumberOfIterations(self, NumberOfIterations):
        r"""SetNumberOfIterations(MinMaxCurvatureFlowImageFilter self, uint32_t NumberOfIterations)"""
        return _SimpleITK.MinMaxCurvatureFlowImageFilter_SetNumberOfIterations(self, NumberOfIterations)

    def GetNumberOfIterations(self):
        r"""GetNumberOfIterations(MinMaxCurvatureFlowImageFilter self) -> uint32_t"""
        return _SimpleITK.MinMaxCurvatureFlowImageFilter_GetNumberOfIterations(self)

    def SetStencilRadius(self, StencilRadius):
        r"""SetStencilRadius(MinMaxCurvatureFlowImageFilter self, int StencilRadius)"""
        return _SimpleITK.MinMaxCurvatureFlowImageFilter_SetStencilRadius(self, StencilRadius)

    def GetStencilRadius(self):
        r"""GetStencilRadius(MinMaxCurvatureFlowImageFilter self) -> int"""
        return _SimpleITK.MinMaxCurvatureFlowImageFilter_GetStencilRadius(self)

    def GetName(self):
        r"""GetName(MinMaxCurvatureFlowImageFilter self) -> std::string"""
        return _SimpleITK.MinMaxCurvatureFlowImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(MinMaxCurvatureFlowImageFilter self) -> std::string"""
        return _SimpleITK.MinMaxCurvatureFlowImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(MinMaxCurvatureFlowImageFilter self, Image image1) -> Image"""
        return _SimpleITK.MinMaxCurvatureFlowImageFilter_Execute(self, image1)

# Register MinMaxCurvatureFlowImageFilter in _SimpleITK:
_SimpleITK.MinMaxCurvatureFlowImageFilter_swigregister(MinMaxCurvatureFlowImageFilter)

def MinMaxCurvatureFlow(image1, timeStep=0.05, numberOfIterations=5, stencilRadius=2):
    r"""MinMaxCurvatureFlow(Image image1, double timeStep=0.05, uint32_t numberOfIterations=5, int stencilRadius=2) -> Image"""
    return _SimpleITK.MinMaxCurvatureFlow(image1, timeStep, numberOfIterations, stencilRadius)
class MinimumImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::MinimumImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_MinimumImageFilter

    def __init__(self):
        r"""__init__(MinimumImageFilter self) -> MinimumImageFilter"""
        _SimpleITK.MinimumImageFilter_swiginit(self, _SimpleITK.new_MinimumImageFilter())

    def GetName(self):
        r"""GetName(MinimumImageFilter self) -> std::string"""
        return _SimpleITK.MinimumImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(MinimumImageFilter self) -> std::string"""
        return _SimpleITK.MinimumImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(MinimumImageFilter self, Image image1, Image image2) -> Image
        Execute(MinimumImageFilter self, Image image1, double constant) -> Image
        Execute(MinimumImageFilter self, double constant, Image image2) -> Image
        """
        return _SimpleITK.MinimumImageFilter_Execute(self, *args)

# Register MinimumImageFilter in _SimpleITK:
_SimpleITK.MinimumImageFilter_swigregister(MinimumImageFilter)

def Minimum(*args):
    r"""
    Minimum(Image image1, Image image2) -> Image
    Minimum(Image image1, double constant) -> Image
    Minimum(double constant, Image image2) -> Image
    """
    return _SimpleITK.Minimum(*args)
class MinimumMaximumImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::MinimumMaximumImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_MinimumMaximumImageFilter

    def __init__(self):
        r"""__init__(MinimumMaximumImageFilter self) -> MinimumMaximumImageFilter"""
        _SimpleITK.MinimumMaximumImageFilter_swiginit(self, _SimpleITK.new_MinimumMaximumImageFilter())

    def GetMinimum(self):
        r"""GetMinimum(MinimumMaximumImageFilter self) -> double"""
        return _SimpleITK.MinimumMaximumImageFilter_GetMinimum(self)

    def GetMaximum(self):
        r"""GetMaximum(MinimumMaximumImageFilter self) -> double"""
        return _SimpleITK.MinimumMaximumImageFilter_GetMaximum(self)

    def GetName(self):
        r"""GetName(MinimumMaximumImageFilter self) -> std::string"""
        return _SimpleITK.MinimumMaximumImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(MinimumMaximumImageFilter self) -> std::string"""
        return _SimpleITK.MinimumMaximumImageFilter___str__(self)

    def Execute(self, image):
        r"""Execute(MinimumMaximumImageFilter self, Image image)"""
        return _SimpleITK.MinimumMaximumImageFilter_Execute(self, image)

# Register MinimumMaximumImageFilter in _SimpleITK:
_SimpleITK.MinimumMaximumImageFilter_swigregister(MinimumMaximumImageFilter)
class MinimumProjectionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::MinimumProjectionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_MinimumProjectionImageFilter

    def __init__(self):
        r"""__init__(MinimumProjectionImageFilter self) -> MinimumProjectionImageFilter"""
        _SimpleITK.MinimumProjectionImageFilter_swiginit(self, _SimpleITK.new_MinimumProjectionImageFilter())

    def SetProjectionDimension(self, ProjectionDimension):
        r"""SetProjectionDimension(MinimumProjectionImageFilter self, unsigned int ProjectionDimension)"""
        return _SimpleITK.MinimumProjectionImageFilter_SetProjectionDimension(self, ProjectionDimension)

    def GetProjectionDimension(self):
        r"""GetProjectionDimension(MinimumProjectionImageFilter self) -> unsigned int"""
        return _SimpleITK.MinimumProjectionImageFilter_GetProjectionDimension(self)

    def GetName(self):
        r"""GetName(MinimumProjectionImageFilter self) -> std::string"""
        return _SimpleITK.MinimumProjectionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(MinimumProjectionImageFilter self) -> std::string"""
        return _SimpleITK.MinimumProjectionImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(MinimumProjectionImageFilter self, Image image1) -> Image"""
        return _SimpleITK.MinimumProjectionImageFilter_Execute(self, image1)

# Register MinimumProjectionImageFilter in _SimpleITK:
_SimpleITK.MinimumProjectionImageFilter_swigregister(MinimumProjectionImageFilter)

def MinimumProjection(image1, projectionDimension=0):
    r"""MinimumProjection(Image image1, unsigned int projectionDimension=0) -> Image"""
    return _SimpleITK.MinimumProjection(image1, projectionDimension)
class MirrorPadImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::MirrorPadImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_MirrorPadImageFilter

    def __init__(self):
        r"""__init__(MirrorPadImageFilter self) -> MirrorPadImageFilter"""
        _SimpleITK.MirrorPadImageFilter_swiginit(self, _SimpleITK.new_MirrorPadImageFilter())

    def SetPadLowerBound(self, PadLowerBound):
        r"""SetPadLowerBound(MirrorPadImageFilter self, VectorUInt32 PadLowerBound)"""
        return _SimpleITK.MirrorPadImageFilter_SetPadLowerBound(self, PadLowerBound)

    def GetPadLowerBound(self):
        r"""GetPadLowerBound(MirrorPadImageFilter self) -> VectorUInt32"""
        return _SimpleITK.MirrorPadImageFilter_GetPadLowerBound(self)

    def SetPadUpperBound(self, PadUpperBound):
        r"""SetPadUpperBound(MirrorPadImageFilter self, VectorUInt32 PadUpperBound)"""
        return _SimpleITK.MirrorPadImageFilter_SetPadUpperBound(self, PadUpperBound)

    def GetPadUpperBound(self):
        r"""GetPadUpperBound(MirrorPadImageFilter self) -> VectorUInt32"""
        return _SimpleITK.MirrorPadImageFilter_GetPadUpperBound(self)

    def SetDecayBase(self, DecayBase):
        r"""SetDecayBase(MirrorPadImageFilter self, double DecayBase)"""
        return _SimpleITK.MirrorPadImageFilter_SetDecayBase(self, DecayBase)

    def GetDecayBase(self):
        r"""GetDecayBase(MirrorPadImageFilter self) -> double"""
        return _SimpleITK.MirrorPadImageFilter_GetDecayBase(self)

    def GetName(self):
        r"""GetName(MirrorPadImageFilter self) -> std::string"""
        return _SimpleITK.MirrorPadImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(MirrorPadImageFilter self) -> std::string"""
        return _SimpleITK.MirrorPadImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(MirrorPadImageFilter self, Image image1) -> Image"""
        return _SimpleITK.MirrorPadImageFilter_Execute(self, image1)

# Register MirrorPadImageFilter in _SimpleITK:
_SimpleITK.MirrorPadImageFilter_swigregister(MirrorPadImageFilter)

def MirrorPad(*args, **kwargs):
    r"""MirrorPad(Image image1, VectorUInt32 padLowerBound=std::vector< unsigned int >(3, 0), VectorUInt32 padUpperBound=std::vector< unsigned int >(3, 0), double decayBase=1.0) -> Image"""
    return _SimpleITK.MirrorPad(*args, **kwargs)
class ModulusImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ModulusImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ModulusImageFilter

    def __init__(self):
        r"""__init__(ModulusImageFilter self) -> ModulusImageFilter"""
        _SimpleITK.ModulusImageFilter_swiginit(self, _SimpleITK.new_ModulusImageFilter())

    def GetName(self):
        r"""GetName(ModulusImageFilter self) -> std::string"""
        return _SimpleITK.ModulusImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ModulusImageFilter self) -> std::string"""
        return _SimpleITK.ModulusImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(ModulusImageFilter self, Image image1, Image image2) -> Image
        Execute(ModulusImageFilter self, Image image1, uint32_t constant) -> Image
        Execute(ModulusImageFilter self, uint32_t constant, Image image2) -> Image
        """
        return _SimpleITK.ModulusImageFilter_Execute(self, *args)

# Register ModulusImageFilter in _SimpleITK:
_SimpleITK.ModulusImageFilter_swigregister(ModulusImageFilter)

def Modulus(*args):
    r"""
    Modulus(Image image1, Image image2) -> Image
    Modulus(Image image1, uint32_t constant) -> Image
    Modulus(uint32_t constant, Image image2) -> Image
    """
    return _SimpleITK.Modulus(*args)
class MomentsThresholdImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::MomentsThresholdImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_MomentsThresholdImageFilter

    def __init__(self):
        r"""__init__(MomentsThresholdImageFilter self) -> MomentsThresholdImageFilter"""
        _SimpleITK.MomentsThresholdImageFilter_swiginit(self, _SimpleITK.new_MomentsThresholdImageFilter())

    def SetInsideValue(self, InsideValue):
        r"""SetInsideValue(MomentsThresholdImageFilter self, uint8_t InsideValue)"""
        return _SimpleITK.MomentsThresholdImageFilter_SetInsideValue(self, InsideValue)

    def GetInsideValue(self):
        r"""GetInsideValue(MomentsThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.MomentsThresholdImageFilter_GetInsideValue(self)

    def SetOutsideValue(self, OutsideValue):
        r"""SetOutsideValue(MomentsThresholdImageFilter self, uint8_t OutsideValue)"""
        return _SimpleITK.MomentsThresholdImageFilter_SetOutsideValue(self, OutsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(MomentsThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.MomentsThresholdImageFilter_GetOutsideValue(self)

    def SetNumberOfHistogramBins(self, NumberOfHistogramBins):
        r"""SetNumberOfHistogramBins(MomentsThresholdImageFilter self, uint32_t NumberOfHistogramBins)"""
        return _SimpleITK.MomentsThresholdImageFilter_SetNumberOfHistogramBins(self, NumberOfHistogramBins)

    def GetNumberOfHistogramBins(self):
        r"""GetNumberOfHistogramBins(MomentsThresholdImageFilter self) -> uint32_t"""
        return _SimpleITK.MomentsThresholdImageFilter_GetNumberOfHistogramBins(self)

    def SetMaskOutput(self, MaskOutput):
        r"""SetMaskOutput(MomentsThresholdImageFilter self, bool MaskOutput)"""
        return _SimpleITK.MomentsThresholdImageFilter_SetMaskOutput(self, MaskOutput)

    def MaskOutputOn(self):
        r"""MaskOutputOn(MomentsThresholdImageFilter self)"""
        return _SimpleITK.MomentsThresholdImageFilter_MaskOutputOn(self)

    def MaskOutputOff(self):
        r"""MaskOutputOff(MomentsThresholdImageFilter self)"""
        return _SimpleITK.MomentsThresholdImageFilter_MaskOutputOff(self)

    def GetMaskOutput(self):
        r"""GetMaskOutput(MomentsThresholdImageFilter self) -> bool"""
        return _SimpleITK.MomentsThresholdImageFilter_GetMaskOutput(self)

    def SetMaskValue(self, MaskValue):
        r"""SetMaskValue(MomentsThresholdImageFilter self, uint8_t MaskValue)"""
        return _SimpleITK.MomentsThresholdImageFilter_SetMaskValue(self, MaskValue)

    def GetMaskValue(self):
        r"""GetMaskValue(MomentsThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.MomentsThresholdImageFilter_GetMaskValue(self)

    def GetThreshold(self):
        r"""GetThreshold(MomentsThresholdImageFilter self) -> double"""
        return _SimpleITK.MomentsThresholdImageFilter_GetThreshold(self)

    def GetName(self):
        r"""GetName(MomentsThresholdImageFilter self) -> std::string"""
        return _SimpleITK.MomentsThresholdImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(MomentsThresholdImageFilter self) -> std::string"""
        return _SimpleITK.MomentsThresholdImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(MomentsThresholdImageFilter self, Image image, Image maskImage) -> Image
        Execute(MomentsThresholdImageFilter self, Image image) -> Image
        """
        return _SimpleITK.MomentsThresholdImageFilter_Execute(self, *args)

# Register MomentsThresholdImageFilter in _SimpleITK:
_SimpleITK.MomentsThresholdImageFilter_swigregister(MomentsThresholdImageFilter)

def MomentsThreshold(*args):
    r"""
    MomentsThreshold(Image image, Image maskImage, uint8_t insideValue=1, uint8_t outsideValue=0, uint32_t numberOfHistogramBins=256, bool maskOutput=True, uint8_t maskValue=255) -> Image
    MomentsThreshold(Image image, uint8_t insideValue=1, uint8_t outsideValue=0, uint32_t numberOfHistogramBins=256, bool maskOutput=True, uint8_t maskValue=255) -> Image
    """
    return _SimpleITK.MomentsThreshold(*args)
class MorphologicalGradientImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::MorphologicalGradientImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_MorphologicalGradientImageFilter

    def __init__(self):
        r"""__init__(MorphologicalGradientImageFilter self) -> MorphologicalGradientImageFilter"""
        _SimpleITK.MorphologicalGradientImageFilter_swiginit(self, _SimpleITK.new_MorphologicalGradientImageFilter())

    def SetKernelRadius(self, *args):
        r"""
        SetKernelRadius(MorphologicalGradientImageFilter self, VectorUInt32 KernelRadius)
        SetKernelRadius(MorphologicalGradientImageFilter self, unsigned int value)
        """
        return _SimpleITK.MorphologicalGradientImageFilter_SetKernelRadius(self, *args)

    def GetKernelRadius(self):
        r"""GetKernelRadius(MorphologicalGradientImageFilter self) -> VectorUInt32"""
        return _SimpleITK.MorphologicalGradientImageFilter_GetKernelRadius(self)

    def SetKernelType(self, KernelType):
        r"""SetKernelType(MorphologicalGradientImageFilter self, slicer_itk::simple::KernelEnum KernelType)"""
        return _SimpleITK.MorphologicalGradientImageFilter_SetKernelType(self, KernelType)

    def GetKernelType(self):
        r"""GetKernelType(MorphologicalGradientImageFilter self) -> slicer_itk::simple::KernelEnum"""
        return _SimpleITK.MorphologicalGradientImageFilter_GetKernelType(self)

    def GetName(self):
        r"""GetName(MorphologicalGradientImageFilter self) -> std::string"""
        return _SimpleITK.MorphologicalGradientImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(MorphologicalGradientImageFilter self) -> std::string"""
        return _SimpleITK.MorphologicalGradientImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(MorphologicalGradientImageFilter self, Image image1) -> Image"""
        return _SimpleITK.MorphologicalGradientImageFilter_Execute(self, image1)

# Register MorphologicalGradientImageFilter in _SimpleITK:
_SimpleITK.MorphologicalGradientImageFilter_swigregister(MorphologicalGradientImageFilter)

def MorphologicalGradient(*args, **kwargs):
    r"""MorphologicalGradient(Image image1, VectorUInt32 kernelRadius=std::vector< uint32_t >(3, 1), slicer_itk::simple::KernelEnum kernelType=sitkBall) -> Image"""
    return _SimpleITK.MorphologicalGradient(*args, **kwargs)
class MorphologicalWatershedFromMarkersImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::MorphologicalWatershedFromMarkersImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_MorphologicalWatershedFromMarkersImageFilter

    def __init__(self):
        r"""__init__(MorphologicalWatershedFromMarkersImageFilter self) -> MorphologicalWatershedFromMarkersImageFilter"""
        _SimpleITK.MorphologicalWatershedFromMarkersImageFilter_swiginit(self, _SimpleITK.new_MorphologicalWatershedFromMarkersImageFilter())

    def SetMarkWatershedLine(self, MarkWatershedLine):
        r"""SetMarkWatershedLine(MorphologicalWatershedFromMarkersImageFilter self, bool MarkWatershedLine)"""
        return _SimpleITK.MorphologicalWatershedFromMarkersImageFilter_SetMarkWatershedLine(self, MarkWatershedLine)

    def MarkWatershedLineOn(self):
        r"""MarkWatershedLineOn(MorphologicalWatershedFromMarkersImageFilter self)"""
        return _SimpleITK.MorphologicalWatershedFromMarkersImageFilter_MarkWatershedLineOn(self)

    def MarkWatershedLineOff(self):
        r"""MarkWatershedLineOff(MorphologicalWatershedFromMarkersImageFilter self)"""
        return _SimpleITK.MorphologicalWatershedFromMarkersImageFilter_MarkWatershedLineOff(self)

    def GetMarkWatershedLine(self):
        r"""GetMarkWatershedLine(MorphologicalWatershedFromMarkersImageFilter self) -> bool"""
        return _SimpleITK.MorphologicalWatershedFromMarkersImageFilter_GetMarkWatershedLine(self)

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(MorphologicalWatershedFromMarkersImageFilter self, bool FullyConnected)"""
        return _SimpleITK.MorphologicalWatershedFromMarkersImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(MorphologicalWatershedFromMarkersImageFilter self)"""
        return _SimpleITK.MorphologicalWatershedFromMarkersImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(MorphologicalWatershedFromMarkersImageFilter self)"""
        return _SimpleITK.MorphologicalWatershedFromMarkersImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(MorphologicalWatershedFromMarkersImageFilter self) -> bool"""
        return _SimpleITK.MorphologicalWatershedFromMarkersImageFilter_GetFullyConnected(self)

    def GetName(self):
        r"""GetName(MorphologicalWatershedFromMarkersImageFilter self) -> std::string"""
        return _SimpleITK.MorphologicalWatershedFromMarkersImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(MorphologicalWatershedFromMarkersImageFilter self) -> std::string"""
        return _SimpleITK.MorphologicalWatershedFromMarkersImageFilter___str__(self)

    def Execute(self, image, markerImage):
        r"""Execute(MorphologicalWatershedFromMarkersImageFilter self, Image image, Image markerImage) -> Image"""
        return _SimpleITK.MorphologicalWatershedFromMarkersImageFilter_Execute(self, image, markerImage)

# Register MorphologicalWatershedFromMarkersImageFilter in _SimpleITK:
_SimpleITK.MorphologicalWatershedFromMarkersImageFilter_swigregister(MorphologicalWatershedFromMarkersImageFilter)

def MorphologicalWatershedFromMarkers(image, markerImage, markWatershedLine=True, fullyConnected=False):
    r"""MorphologicalWatershedFromMarkers(Image image, Image markerImage, bool markWatershedLine=True, bool fullyConnected=False) -> Image"""
    return _SimpleITK.MorphologicalWatershedFromMarkers(image, markerImage, markWatershedLine, fullyConnected)
class MorphologicalWatershedImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::MorphologicalWatershedImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_MorphologicalWatershedImageFilter

    def __init__(self):
        r"""__init__(MorphologicalWatershedImageFilter self) -> MorphologicalWatershedImageFilter"""
        _SimpleITK.MorphologicalWatershedImageFilter_swiginit(self, _SimpleITK.new_MorphologicalWatershedImageFilter())

    def SetLevel(self, Level):
        r"""SetLevel(MorphologicalWatershedImageFilter self, double Level)"""
        return _SimpleITK.MorphologicalWatershedImageFilter_SetLevel(self, Level)

    def GetLevel(self):
        r"""GetLevel(MorphologicalWatershedImageFilter self) -> double"""
        return _SimpleITK.MorphologicalWatershedImageFilter_GetLevel(self)

    def SetMarkWatershedLine(self, MarkWatershedLine):
        r"""SetMarkWatershedLine(MorphologicalWatershedImageFilter self, bool MarkWatershedLine)"""
        return _SimpleITK.MorphologicalWatershedImageFilter_SetMarkWatershedLine(self, MarkWatershedLine)

    def MarkWatershedLineOn(self):
        r"""MarkWatershedLineOn(MorphologicalWatershedImageFilter self)"""
        return _SimpleITK.MorphologicalWatershedImageFilter_MarkWatershedLineOn(self)

    def MarkWatershedLineOff(self):
        r"""MarkWatershedLineOff(MorphologicalWatershedImageFilter self)"""
        return _SimpleITK.MorphologicalWatershedImageFilter_MarkWatershedLineOff(self)

    def GetMarkWatershedLine(self):
        r"""GetMarkWatershedLine(MorphologicalWatershedImageFilter self) -> bool"""
        return _SimpleITK.MorphologicalWatershedImageFilter_GetMarkWatershedLine(self)

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(MorphologicalWatershedImageFilter self, bool FullyConnected)"""
        return _SimpleITK.MorphologicalWatershedImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(MorphologicalWatershedImageFilter self)"""
        return _SimpleITK.MorphologicalWatershedImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(MorphologicalWatershedImageFilter self)"""
        return _SimpleITK.MorphologicalWatershedImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(MorphologicalWatershedImageFilter self) -> bool"""
        return _SimpleITK.MorphologicalWatershedImageFilter_GetFullyConnected(self)

    def GetName(self):
        r"""GetName(MorphologicalWatershedImageFilter self) -> std::string"""
        return _SimpleITK.MorphologicalWatershedImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(MorphologicalWatershedImageFilter self) -> std::string"""
        return _SimpleITK.MorphologicalWatershedImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(MorphologicalWatershedImageFilter self, Image image1) -> Image"""
        return _SimpleITK.MorphologicalWatershedImageFilter_Execute(self, image1)

# Register MorphologicalWatershedImageFilter in _SimpleITK:
_SimpleITK.MorphologicalWatershedImageFilter_swigregister(MorphologicalWatershedImageFilter)

def MorphologicalWatershed(image1, level=0.0, markWatershedLine=True, fullyConnected=False):
    r"""MorphologicalWatershed(Image image1, double level=0.0, bool markWatershedLine=True, bool fullyConnected=False) -> Image"""
    return _SimpleITK.MorphologicalWatershed(image1, level, markWatershedLine, fullyConnected)
class MultiLabelSTAPLEImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::MultiLabelSTAPLEImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_MultiLabelSTAPLEImageFilter

    def __init__(self):
        r"""__init__(MultiLabelSTAPLEImageFilter self) -> MultiLabelSTAPLEImageFilter"""
        _SimpleITK.MultiLabelSTAPLEImageFilter_swiginit(self, _SimpleITK.new_MultiLabelSTAPLEImageFilter())

    def SetLabelForUndecidedPixels(self, LabelForUndecidedPixels):
        r"""SetLabelForUndecidedPixels(MultiLabelSTAPLEImageFilter self, uint64_t LabelForUndecidedPixels)"""
        return _SimpleITK.MultiLabelSTAPLEImageFilter_SetLabelForUndecidedPixels(self, LabelForUndecidedPixels)

    def GetLabelForUndecidedPixels(self):
        r"""GetLabelForUndecidedPixels(MultiLabelSTAPLEImageFilter self) -> uint64_t"""
        return _SimpleITK.MultiLabelSTAPLEImageFilter_GetLabelForUndecidedPixels(self)

    def SetTerminationUpdateThreshold(self, TerminationUpdateThreshold):
        r"""SetTerminationUpdateThreshold(MultiLabelSTAPLEImageFilter self, float TerminationUpdateThreshold)"""
        return _SimpleITK.MultiLabelSTAPLEImageFilter_SetTerminationUpdateThreshold(self, TerminationUpdateThreshold)

    def GetTerminationUpdateThreshold(self):
        r"""GetTerminationUpdateThreshold(MultiLabelSTAPLEImageFilter self) -> float"""
        return _SimpleITK.MultiLabelSTAPLEImageFilter_GetTerminationUpdateThreshold(self)

    def SetMaximumNumberOfIterations(self, MaximumNumberOfIterations):
        r"""SetMaximumNumberOfIterations(MultiLabelSTAPLEImageFilter self, unsigned int MaximumNumberOfIterations)"""
        return _SimpleITK.MultiLabelSTAPLEImageFilter_SetMaximumNumberOfIterations(self, MaximumNumberOfIterations)

    def GetMaximumNumberOfIterations(self):
        r"""GetMaximumNumberOfIterations(MultiLabelSTAPLEImageFilter self) -> unsigned int"""
        return _SimpleITK.MultiLabelSTAPLEImageFilter_GetMaximumNumberOfIterations(self)

    def SetPriorProbabilities(self, PriorProbabilities):
        r"""SetPriorProbabilities(MultiLabelSTAPLEImageFilter self, VectorFloat PriorProbabilities)"""
        return _SimpleITK.MultiLabelSTAPLEImageFilter_SetPriorProbabilities(self, PriorProbabilities)

    def GetPriorProbabilities(self):
        r"""GetPriorProbabilities(MultiLabelSTAPLEImageFilter self) -> VectorFloat"""
        return _SimpleITK.MultiLabelSTAPLEImageFilter_GetPriorProbabilities(self)

    def GetConfusionMatrix(self, input):
        r"""GetConfusionMatrix(MultiLabelSTAPLEImageFilter self, unsigned int input) -> VectorFloat"""
        return _SimpleITK.MultiLabelSTAPLEImageFilter_GetConfusionMatrix(self, input)

    def GetName(self):
        r"""GetName(MultiLabelSTAPLEImageFilter self) -> std::string"""
        return _SimpleITK.MultiLabelSTAPLEImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(MultiLabelSTAPLEImageFilter self) -> std::string"""
        return _SimpleITK.MultiLabelSTAPLEImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(MultiLabelSTAPLEImageFilter self, VectorOfImage images) -> Image
        Execute(MultiLabelSTAPLEImageFilter self, Image image1) -> Image
        Execute(MultiLabelSTAPLEImageFilter self, Image image1, Image image2) -> Image
        Execute(MultiLabelSTAPLEImageFilter self, Image image1, Image image2, Image image3) -> Image
        Execute(MultiLabelSTAPLEImageFilter self, Image image1, Image image2, Image image3, Image image4) -> Image
        Execute(MultiLabelSTAPLEImageFilter self, Image image1, Image image2, Image image3, Image image4, Image image5) -> Image
        """
        return _SimpleITK.MultiLabelSTAPLEImageFilter_Execute(self, *args)

# Register MultiLabelSTAPLEImageFilter in _SimpleITK:
_SimpleITK.MultiLabelSTAPLEImageFilter_swigregister(MultiLabelSTAPLEImageFilter)

def MultiLabelSTAPLE(*args):
    r"""
    MultiLabelSTAPLE(VectorOfImage images, uint64_t labelForUndecidedPixels=std::numeric_limits< uint64_t >::max(), float terminationUpdateThreshold=1e-5, unsigned int maximumNumberOfIterations=std::numeric_limits< unsigned int >::max(), VectorFloat priorProbabilities=std::vector< float >()) -> Image
    MultiLabelSTAPLE(Image image1, uint64_t labelForUndecidedPixels=std::numeric_limits< uint64_t >::max(), float terminationUpdateThreshold=1e-5, unsigned int maximumNumberOfIterations=std::numeric_limits< unsigned int >::max(), VectorFloat priorProbabilities=std::vector< float >()) -> Image
    MultiLabelSTAPLE(Image image1, Image image2, uint64_t labelForUndecidedPixels=std::numeric_limits< uint64_t >::max(), float terminationUpdateThreshold=1e-5, unsigned int maximumNumberOfIterations=std::numeric_limits< unsigned int >::max(), VectorFloat priorProbabilities=std::vector< float >()) -> Image
    MultiLabelSTAPLE(Image image1, Image image2, Image image3, uint64_t labelForUndecidedPixels=std::numeric_limits< uint64_t >::max(), float terminationUpdateThreshold=1e-5, unsigned int maximumNumberOfIterations=std::numeric_limits< unsigned int >::max(), VectorFloat priorProbabilities=std::vector< float >()) -> Image
    MultiLabelSTAPLE(Image image1, Image image2, Image image3, Image image4, uint64_t labelForUndecidedPixels=std::numeric_limits< uint64_t >::max(), float terminationUpdateThreshold=1e-5, unsigned int maximumNumberOfIterations=std::numeric_limits< unsigned int >::max(), VectorFloat priorProbabilities=std::vector< float >()) -> Image
    MultiLabelSTAPLE(Image image1, Image image2, Image image3, Image image4, Image image5, uint64_t labelForUndecidedPixels=std::numeric_limits< uint64_t >::max(), float terminationUpdateThreshold=1e-5, unsigned int maximumNumberOfIterations=std::numeric_limits< unsigned int >::max(), VectorFloat priorProbabilities=std::vector< float >()) -> Image
    """
    return _SimpleITK.MultiLabelSTAPLE(*args)
class MultiplyImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::MultiplyImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_MultiplyImageFilter

    def __init__(self):
        r"""__init__(MultiplyImageFilter self) -> MultiplyImageFilter"""
        _SimpleITK.MultiplyImageFilter_swiginit(self, _SimpleITK.new_MultiplyImageFilter())

    def GetName(self):
        r"""GetName(MultiplyImageFilter self) -> std::string"""
        return _SimpleITK.MultiplyImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(MultiplyImageFilter self) -> std::string"""
        return _SimpleITK.MultiplyImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(MultiplyImageFilter self, Image image1, Image image2) -> Image
        Execute(MultiplyImageFilter self, Image image1, double constant) -> Image
        Execute(MultiplyImageFilter self, double constant, Image image2) -> Image
        """
        return _SimpleITK.MultiplyImageFilter_Execute(self, *args)

# Register MultiplyImageFilter in _SimpleITK:
_SimpleITK.MultiplyImageFilter_swigregister(MultiplyImageFilter)

def Multiply(*args):
    r"""
    Multiply(Image image1, Image image2) -> Image
    Multiply(Image image1, double constant) -> Image
    Multiply(double constant, Image image2) -> Image
    """
    return _SimpleITK.Multiply(*args)
class N4BiasFieldCorrectionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::N4BiasFieldCorrectionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_N4BiasFieldCorrectionImageFilter

    def __init__(self):
        r"""__init__(N4BiasFieldCorrectionImageFilter self) -> N4BiasFieldCorrectionImageFilter"""
        _SimpleITK.N4BiasFieldCorrectionImageFilter_swiginit(self, _SimpleITK.new_N4BiasFieldCorrectionImageFilter())

    def SetConvergenceThreshold(self, ConvergenceThreshold):
        r"""SetConvergenceThreshold(N4BiasFieldCorrectionImageFilter self, double ConvergenceThreshold)"""
        return _SimpleITK.N4BiasFieldCorrectionImageFilter_SetConvergenceThreshold(self, ConvergenceThreshold)

    def GetConvergenceThreshold(self):
        r"""GetConvergenceThreshold(N4BiasFieldCorrectionImageFilter self) -> double"""
        return _SimpleITK.N4BiasFieldCorrectionImageFilter_GetConvergenceThreshold(self)

    def SetMaximumNumberOfIterations(self, MaximumNumberOfIterations):
        r"""SetMaximumNumberOfIterations(N4BiasFieldCorrectionImageFilter self, VectorUInt32 MaximumNumberOfIterations)"""
        return _SimpleITK.N4BiasFieldCorrectionImageFilter_SetMaximumNumberOfIterations(self, MaximumNumberOfIterations)

    def GetMaximumNumberOfIterations(self):
        r"""GetMaximumNumberOfIterations(N4BiasFieldCorrectionImageFilter self) -> VectorUInt32"""
        return _SimpleITK.N4BiasFieldCorrectionImageFilter_GetMaximumNumberOfIterations(self)

    def SetBiasFieldFullWidthAtHalfMaximum(self, BiasFieldFullWidthAtHalfMaximum):
        r"""SetBiasFieldFullWidthAtHalfMaximum(N4BiasFieldCorrectionImageFilter self, double BiasFieldFullWidthAtHalfMaximum)"""
        return _SimpleITK.N4BiasFieldCorrectionImageFilter_SetBiasFieldFullWidthAtHalfMaximum(self, BiasFieldFullWidthAtHalfMaximum)

    def GetBiasFieldFullWidthAtHalfMaximum(self):
        r"""GetBiasFieldFullWidthAtHalfMaximum(N4BiasFieldCorrectionImageFilter self) -> double"""
        return _SimpleITK.N4BiasFieldCorrectionImageFilter_GetBiasFieldFullWidthAtHalfMaximum(self)

    def SetWienerFilterNoise(self, WienerFilterNoise):
        r"""SetWienerFilterNoise(N4BiasFieldCorrectionImageFilter self, double WienerFilterNoise)"""
        return _SimpleITK.N4BiasFieldCorrectionImageFilter_SetWienerFilterNoise(self, WienerFilterNoise)

    def GetWienerFilterNoise(self):
        r"""GetWienerFilterNoise(N4BiasFieldCorrectionImageFilter self) -> double"""
        return _SimpleITK.N4BiasFieldCorrectionImageFilter_GetWienerFilterNoise(self)

    def SetNumberOfHistogramBins(self, NumberOfHistogramBins):
        r"""SetNumberOfHistogramBins(N4BiasFieldCorrectionImageFilter self, uint32_t NumberOfHistogramBins)"""
        return _SimpleITK.N4BiasFieldCorrectionImageFilter_SetNumberOfHistogramBins(self, NumberOfHistogramBins)

    def GetNumberOfHistogramBins(self):
        r"""GetNumberOfHistogramBins(N4BiasFieldCorrectionImageFilter self) -> uint32_t"""
        return _SimpleITK.N4BiasFieldCorrectionImageFilter_GetNumberOfHistogramBins(self)

    def SetNumberOfControlPoints(self, *args):
        r"""
        SetNumberOfControlPoints(N4BiasFieldCorrectionImageFilter self, VectorUInt32 NumberOfControlPoints)
        SetNumberOfControlPoints(N4BiasFieldCorrectionImageFilter self, uint32_t value)
        """
        return _SimpleITK.N4BiasFieldCorrectionImageFilter_SetNumberOfControlPoints(self, *args)

    def GetNumberOfControlPoints(self):
        r"""GetNumberOfControlPoints(N4BiasFieldCorrectionImageFilter self) -> VectorUInt32"""
        return _SimpleITK.N4BiasFieldCorrectionImageFilter_GetNumberOfControlPoints(self)

    def SetSplineOrder(self, SplineOrder):
        r"""SetSplineOrder(N4BiasFieldCorrectionImageFilter self, uint32_t SplineOrder)"""
        return _SimpleITK.N4BiasFieldCorrectionImageFilter_SetSplineOrder(self, SplineOrder)

    def GetSplineOrder(self):
        r"""GetSplineOrder(N4BiasFieldCorrectionImageFilter self) -> uint32_t"""
        return _SimpleITK.N4BiasFieldCorrectionImageFilter_GetSplineOrder(self)

    def SetUseMaskLabel(self, UseMaskLabel):
        r"""SetUseMaskLabel(N4BiasFieldCorrectionImageFilter self, bool UseMaskLabel)"""
        return _SimpleITK.N4BiasFieldCorrectionImageFilter_SetUseMaskLabel(self, UseMaskLabel)

    def UseMaskLabelOn(self):
        r"""UseMaskLabelOn(N4BiasFieldCorrectionImageFilter self)"""
        return _SimpleITK.N4BiasFieldCorrectionImageFilter_UseMaskLabelOn(self)

    def UseMaskLabelOff(self):
        r"""UseMaskLabelOff(N4BiasFieldCorrectionImageFilter self)"""
        return _SimpleITK.N4BiasFieldCorrectionImageFilter_UseMaskLabelOff(self)

    def GetUseMaskLabel(self):
        r"""GetUseMaskLabel(N4BiasFieldCorrectionImageFilter self) -> bool"""
        return _SimpleITK.N4BiasFieldCorrectionImageFilter_GetUseMaskLabel(self)

    def SetMaskLabel(self, MaskLabel):
        r"""SetMaskLabel(N4BiasFieldCorrectionImageFilter self, uint8_t MaskLabel)"""
        return _SimpleITK.N4BiasFieldCorrectionImageFilter_SetMaskLabel(self, MaskLabel)

    def GetMaskLabel(self):
        r"""GetMaskLabel(N4BiasFieldCorrectionImageFilter self) -> uint8_t"""
        return _SimpleITK.N4BiasFieldCorrectionImageFilter_GetMaskLabel(self)

    def GetCurrentLevel(self):
        r"""GetCurrentLevel(N4BiasFieldCorrectionImageFilter self) -> uint32_t"""
        return _SimpleITK.N4BiasFieldCorrectionImageFilter_GetCurrentLevel(self)

    def GetElapsedIterations(self):
        r"""GetElapsedIterations(N4BiasFieldCorrectionImageFilter self) -> uint32_t"""
        return _SimpleITK.N4BiasFieldCorrectionImageFilter_GetElapsedIterations(self)

    def GetCurrentConvergenceMeasurement(self):
        r"""GetCurrentConvergenceMeasurement(N4BiasFieldCorrectionImageFilter self) -> double"""
        return _SimpleITK.N4BiasFieldCorrectionImageFilter_GetCurrentConvergenceMeasurement(self)

    def GetLogBiasFieldAsImage(self, referenceImage):
        r"""GetLogBiasFieldAsImage(N4BiasFieldCorrectionImageFilter self, Image referenceImage) -> Image"""
        return _SimpleITK.N4BiasFieldCorrectionImageFilter_GetLogBiasFieldAsImage(self, referenceImage)

    def GetName(self):
        r"""GetName(N4BiasFieldCorrectionImageFilter self) -> std::string"""
        return _SimpleITK.N4BiasFieldCorrectionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(N4BiasFieldCorrectionImageFilter self) -> std::string"""
        return _SimpleITK.N4BiasFieldCorrectionImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(N4BiasFieldCorrectionImageFilter self, Image image, Image maskImage) -> Image
        Execute(N4BiasFieldCorrectionImageFilter self, Image image) -> Image
        """
        return _SimpleITK.N4BiasFieldCorrectionImageFilter_Execute(self, *args)

# Register N4BiasFieldCorrectionImageFilter in _SimpleITK:
_SimpleITK.N4BiasFieldCorrectionImageFilter_swigregister(N4BiasFieldCorrectionImageFilter)

def N4BiasFieldCorrection(*args):
    r"""
    N4BiasFieldCorrection(Image image, Image maskImage, double convergenceThreshold=0.001, VectorUInt32 maximumNumberOfIterations=std::vector< uint32_t >(4,50), double biasFieldFullWidthAtHalfMaximum=0.15, double wienerFilterNoise=0.01, uint32_t numberOfHistogramBins=200, VectorUInt32 numberOfControlPoints=std::vector< uint32_t >(3, 4), uint32_t splineOrder=3, bool useMaskLabel=True, uint8_t maskLabel=1) -> Image
    N4BiasFieldCorrection(Image image, double convergenceThreshold=0.001, VectorUInt32 maximumNumberOfIterations=std::vector< uint32_t >(4,50), double biasFieldFullWidthAtHalfMaximum=0.15, double wienerFilterNoise=0.01, uint32_t numberOfHistogramBins=200, VectorUInt32 numberOfControlPoints=std::vector< uint32_t >(3, 4), uint32_t splineOrder=3, bool useMaskLabel=True, uint8_t maskLabel=1) -> Image
    """
    return _SimpleITK.N4BiasFieldCorrection(*args)
class NaryAddImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::NaryAddImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_NaryAddImageFilter

    def __init__(self):
        r"""__init__(NaryAddImageFilter self) -> NaryAddImageFilter"""
        _SimpleITK.NaryAddImageFilter_swiginit(self, _SimpleITK.new_NaryAddImageFilter())

    def GetName(self):
        r"""GetName(NaryAddImageFilter self) -> std::string"""
        return _SimpleITK.NaryAddImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(NaryAddImageFilter self) -> std::string"""
        return _SimpleITK.NaryAddImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(NaryAddImageFilter self, VectorOfImage images) -> Image
        Execute(NaryAddImageFilter self, Image image1) -> Image
        Execute(NaryAddImageFilter self, Image image1, Image image2) -> Image
        Execute(NaryAddImageFilter self, Image image1, Image image2, Image image3) -> Image
        Execute(NaryAddImageFilter self, Image image1, Image image2, Image image3, Image image4) -> Image
        Execute(NaryAddImageFilter self, Image image1, Image image2, Image image3, Image image4, Image image5) -> Image
        """
        return _SimpleITK.NaryAddImageFilter_Execute(self, *args)

# Register NaryAddImageFilter in _SimpleITK:
_SimpleITK.NaryAddImageFilter_swigregister(NaryAddImageFilter)

def NaryAdd(*args):
    r"""
    NaryAdd(VectorOfImage images) -> Image
    NaryAdd(Image image1) -> Image
    NaryAdd(Image image1, Image image2) -> Image
    NaryAdd(Image image1, Image image2, Image image3) -> Image
    NaryAdd(Image image1, Image image2, Image image3, Image image4) -> Image
    NaryAdd(Image image1, Image image2, Image image3, Image image4, Image image5) -> Image
    """
    return _SimpleITK.NaryAdd(*args)
class NaryMaximumImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::NaryMaximumImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_NaryMaximumImageFilter

    def __init__(self):
        r"""__init__(NaryMaximumImageFilter self) -> NaryMaximumImageFilter"""
        _SimpleITK.NaryMaximumImageFilter_swiginit(self, _SimpleITK.new_NaryMaximumImageFilter())

    def GetName(self):
        r"""GetName(NaryMaximumImageFilter self) -> std::string"""
        return _SimpleITK.NaryMaximumImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(NaryMaximumImageFilter self) -> std::string"""
        return _SimpleITK.NaryMaximumImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(NaryMaximumImageFilter self, VectorOfImage images) -> Image
        Execute(NaryMaximumImageFilter self, Image image1) -> Image
        Execute(NaryMaximumImageFilter self, Image image1, Image image2) -> Image
        Execute(NaryMaximumImageFilter self, Image image1, Image image2, Image image3) -> Image
        Execute(NaryMaximumImageFilter self, Image image1, Image image2, Image image3, Image image4) -> Image
        Execute(NaryMaximumImageFilter self, Image image1, Image image2, Image image3, Image image4, Image image5) -> Image
        """
        return _SimpleITK.NaryMaximumImageFilter_Execute(self, *args)

# Register NaryMaximumImageFilter in _SimpleITK:
_SimpleITK.NaryMaximumImageFilter_swigregister(NaryMaximumImageFilter)

def NaryMaximum(*args):
    r"""
    NaryMaximum(VectorOfImage images) -> Image
    NaryMaximum(Image image1) -> Image
    NaryMaximum(Image image1, Image image2) -> Image
    NaryMaximum(Image image1, Image image2, Image image3) -> Image
    NaryMaximum(Image image1, Image image2, Image image3, Image image4) -> Image
    NaryMaximum(Image image1, Image image2, Image image3, Image image4, Image image5) -> Image
    """
    return _SimpleITK.NaryMaximum(*args)
class NeighborhoodConnectedImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::NeighborhoodConnectedImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_NeighborhoodConnectedImageFilter

    def __init__(self):
        r"""__init__(NeighborhoodConnectedImageFilter self) -> NeighborhoodConnectedImageFilter"""
        _SimpleITK.NeighborhoodConnectedImageFilter_swiginit(self, _SimpleITK.new_NeighborhoodConnectedImageFilter())

    def SetSeedList(self, SeedList):
        r"""SetSeedList(NeighborhoodConnectedImageFilter self, VectorUIntList SeedList)"""
        return _SimpleITK.NeighborhoodConnectedImageFilter_SetSeedList(self, SeedList)

    def GetSeedList(self):
        r"""GetSeedList(NeighborhoodConnectedImageFilter self) -> VectorUIntList"""
        return _SimpleITK.NeighborhoodConnectedImageFilter_GetSeedList(self)

    def AddSeed(self, point):
        r"""AddSeed(NeighborhoodConnectedImageFilter self, VectorUInt32 point)"""
        return _SimpleITK.NeighborhoodConnectedImageFilter_AddSeed(self, point)

    def ClearSeeds(self):
        r"""ClearSeeds(NeighborhoodConnectedImageFilter self)"""
        return _SimpleITK.NeighborhoodConnectedImageFilter_ClearSeeds(self)

    def SetLower(self, Lower):
        r"""SetLower(NeighborhoodConnectedImageFilter self, double Lower)"""
        return _SimpleITK.NeighborhoodConnectedImageFilter_SetLower(self, Lower)

    def GetLower(self):
        r"""GetLower(NeighborhoodConnectedImageFilter self) -> double"""
        return _SimpleITK.NeighborhoodConnectedImageFilter_GetLower(self)

    def SetUpper(self, Upper):
        r"""SetUpper(NeighborhoodConnectedImageFilter self, double Upper)"""
        return _SimpleITK.NeighborhoodConnectedImageFilter_SetUpper(self, Upper)

    def GetUpper(self):
        r"""GetUpper(NeighborhoodConnectedImageFilter self) -> double"""
        return _SimpleITK.NeighborhoodConnectedImageFilter_GetUpper(self)

    def SetRadius(self, *args):
        r"""
        SetRadius(NeighborhoodConnectedImageFilter self, VectorUInt32 Radius)
        SetRadius(NeighborhoodConnectedImageFilter self, unsigned int value)
        """
        return _SimpleITK.NeighborhoodConnectedImageFilter_SetRadius(self, *args)

    def GetRadius(self):
        r"""GetRadius(NeighborhoodConnectedImageFilter self) -> VectorUInt32"""
        return _SimpleITK.NeighborhoodConnectedImageFilter_GetRadius(self)

    def SetReplaceValue(self, ReplaceValue):
        r"""SetReplaceValue(NeighborhoodConnectedImageFilter self, double ReplaceValue)"""
        return _SimpleITK.NeighborhoodConnectedImageFilter_SetReplaceValue(self, ReplaceValue)

    def GetReplaceValue(self):
        r"""GetReplaceValue(NeighborhoodConnectedImageFilter self) -> double"""
        return _SimpleITK.NeighborhoodConnectedImageFilter_GetReplaceValue(self)

    def GetName(self):
        r"""GetName(NeighborhoodConnectedImageFilter self) -> std::string"""
        return _SimpleITK.NeighborhoodConnectedImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(NeighborhoodConnectedImageFilter self) -> std::string"""
        return _SimpleITK.NeighborhoodConnectedImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(NeighborhoodConnectedImageFilter self, Image image1) -> Image"""
        return _SimpleITK.NeighborhoodConnectedImageFilter_Execute(self, image1)

# Register NeighborhoodConnectedImageFilter in _SimpleITK:
_SimpleITK.NeighborhoodConnectedImageFilter_swigregister(NeighborhoodConnectedImageFilter)

def NeighborhoodConnected(*args, **kwargs):
    r"""NeighborhoodConnected(Image image1, VectorUIntList seedList=std::vector< std::vector< unsigned int > >(), double lower=0, double upper=1, VectorUInt32 radius=std::vector< unsigned int >(3, 1), double replaceValue=1) -> Image"""
    return _SimpleITK.NeighborhoodConnected(*args, **kwargs)
class NoiseImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::NoiseImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_NoiseImageFilter

    def __init__(self):
        r"""__init__(NoiseImageFilter self) -> NoiseImageFilter"""
        _SimpleITK.NoiseImageFilter_swiginit(self, _SimpleITK.new_NoiseImageFilter())

    def SetRadius(self, *args):
        r"""
        SetRadius(NoiseImageFilter self, VectorUInt32 Radius)
        SetRadius(NoiseImageFilter self, unsigned int value)
        """
        return _SimpleITK.NoiseImageFilter_SetRadius(self, *args)

    def GetRadius(self):
        r"""GetRadius(NoiseImageFilter self) -> VectorUInt32"""
        return _SimpleITK.NoiseImageFilter_GetRadius(self)

    def GetName(self):
        r"""GetName(NoiseImageFilter self) -> std::string"""
        return _SimpleITK.NoiseImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(NoiseImageFilter self) -> std::string"""
        return _SimpleITK.NoiseImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(NoiseImageFilter self, Image image1) -> Image"""
        return _SimpleITK.NoiseImageFilter_Execute(self, image1)

# Register NoiseImageFilter in _SimpleITK:
_SimpleITK.NoiseImageFilter_swigregister(NoiseImageFilter)

def Noise(*args, **kwargs):
    r"""Noise(Image image1, VectorUInt32 radius=std::vector< unsigned int >(3, 1)) -> Image"""
    return _SimpleITK.Noise(*args, **kwargs)
class NormalizeImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::NormalizeImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_NormalizeImageFilter

    def __init__(self):
        r"""__init__(NormalizeImageFilter self) -> NormalizeImageFilter"""
        _SimpleITK.NormalizeImageFilter_swiginit(self, _SimpleITK.new_NormalizeImageFilter())

    def GetName(self):
        r"""GetName(NormalizeImageFilter self) -> std::string"""
        return _SimpleITK.NormalizeImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(NormalizeImageFilter self) -> std::string"""
        return _SimpleITK.NormalizeImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(NormalizeImageFilter self, Image image1) -> Image"""
        return _SimpleITK.NormalizeImageFilter_Execute(self, image1)

# Register NormalizeImageFilter in _SimpleITK:
_SimpleITK.NormalizeImageFilter_swigregister(NormalizeImageFilter)

def Normalize(image1):
    r"""Normalize(Image image1) -> Image"""
    return _SimpleITK.Normalize(image1)
class NormalizeToConstantImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::NormalizeToConstantImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_NormalizeToConstantImageFilter

    def __init__(self):
        r"""__init__(NormalizeToConstantImageFilter self) -> NormalizeToConstantImageFilter"""
        _SimpleITK.NormalizeToConstantImageFilter_swiginit(self, _SimpleITK.new_NormalizeToConstantImageFilter())

    def SetConstant(self, Constant):
        r"""SetConstant(NormalizeToConstantImageFilter self, double Constant)"""
        return _SimpleITK.NormalizeToConstantImageFilter_SetConstant(self, Constant)

    def GetConstant(self):
        r"""GetConstant(NormalizeToConstantImageFilter self) -> double"""
        return _SimpleITK.NormalizeToConstantImageFilter_GetConstant(self)

    def GetName(self):
        r"""GetName(NormalizeToConstantImageFilter self) -> std::string"""
        return _SimpleITK.NormalizeToConstantImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(NormalizeToConstantImageFilter self) -> std::string"""
        return _SimpleITK.NormalizeToConstantImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(NormalizeToConstantImageFilter self, Image image1) -> Image"""
        return _SimpleITK.NormalizeToConstantImageFilter_Execute(self, image1)

# Register NormalizeToConstantImageFilter in _SimpleITK:
_SimpleITK.NormalizeToConstantImageFilter_swigregister(NormalizeToConstantImageFilter)

def NormalizeToConstant(image1, constant=1.0):
    r"""NormalizeToConstant(Image image1, double constant=1.0) -> Image"""
    return _SimpleITK.NormalizeToConstant(image1, constant)
class NormalizedCorrelationImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::NormalizedCorrelationImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_NormalizedCorrelationImageFilter

    def __init__(self):
        r"""__init__(NormalizedCorrelationImageFilter self) -> NormalizedCorrelationImageFilter"""
        _SimpleITK.NormalizedCorrelationImageFilter_swiginit(self, _SimpleITK.new_NormalizedCorrelationImageFilter())

    def GetName(self):
        r"""GetName(NormalizedCorrelationImageFilter self) -> std::string"""
        return _SimpleITK.NormalizedCorrelationImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(NormalizedCorrelationImageFilter self) -> std::string"""
        return _SimpleITK.NormalizedCorrelationImageFilter___str__(self)

    def Execute(self, image, maskImage, templateImage):
        r"""Execute(NormalizedCorrelationImageFilter self, Image image, Image maskImage, Image templateImage) -> Image"""
        return _SimpleITK.NormalizedCorrelationImageFilter_Execute(self, image, maskImage, templateImage)

# Register NormalizedCorrelationImageFilter in _SimpleITK:
_SimpleITK.NormalizedCorrelationImageFilter_swigregister(NormalizedCorrelationImageFilter)

def NormalizedCorrelation(image, maskImage, templateImage):
    r"""NormalizedCorrelation(Image image, Image maskImage, Image templateImage) -> Image"""
    return _SimpleITK.NormalizedCorrelation(image, maskImage, templateImage)
class NotEqualImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::NotEqualImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_NotEqualImageFilter

    def __init__(self):
        r"""__init__(NotEqualImageFilter self) -> NotEqualImageFilter"""
        _SimpleITK.NotEqualImageFilter_swiginit(self, _SimpleITK.new_NotEqualImageFilter())

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(NotEqualImageFilter self, uint8_t BackgroundValue)"""
        return _SimpleITK.NotEqualImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(NotEqualImageFilter self) -> uint8_t"""
        return _SimpleITK.NotEqualImageFilter_GetBackgroundValue(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(NotEqualImageFilter self, uint8_t ForegroundValue)"""
        return _SimpleITK.NotEqualImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(NotEqualImageFilter self) -> uint8_t"""
        return _SimpleITK.NotEqualImageFilter_GetForegroundValue(self)

    def GetName(self):
        r"""GetName(NotEqualImageFilter self) -> std::string"""
        return _SimpleITK.NotEqualImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(NotEqualImageFilter self) -> std::string"""
        return _SimpleITK.NotEqualImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(NotEqualImageFilter self, Image image1, Image image2) -> Image
        Execute(NotEqualImageFilter self, Image image1, double constant) -> Image
        Execute(NotEqualImageFilter self, double constant, Image image2) -> Image
        Execute(NotEqualImageFilter self, Image image1, double constant, uint8_t backgroundValue, uint8_t foregroundValue) -> Image
        Execute(NotEqualImageFilter self, double constant, Image image2, uint8_t backgroundValue, uint8_t foregroundValue) -> Image
        """
        return _SimpleITK.NotEqualImageFilter_Execute(self, *args)

# Register NotEqualImageFilter in _SimpleITK:
_SimpleITK.NotEqualImageFilter_swigregister(NotEqualImageFilter)

def NotEqual(*args):
    r"""
    NotEqual(Image image1, Image image2, uint8_t backgroundValue=0, uint8_t foregroundValue=1) -> Image
    NotEqual(Image image1, double constant, uint8_t backgroundValue=0, uint8_t foregroundValue=1) -> Image
    NotEqual(double constant, Image image2, uint8_t backgroundValue=0, uint8_t foregroundValue=1) -> Image
    """
    return _SimpleITK.NotEqual(*args)
class NotImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::NotImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_NotImageFilter

    def __init__(self):
        r"""__init__(NotImageFilter self) -> NotImageFilter"""
        _SimpleITK.NotImageFilter_swiginit(self, _SimpleITK.new_NotImageFilter())

    def GetName(self):
        r"""GetName(NotImageFilter self) -> std::string"""
        return _SimpleITK.NotImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(NotImageFilter self) -> std::string"""
        return _SimpleITK.NotImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(NotImageFilter self, Image image1) -> Image"""
        return _SimpleITK.NotImageFilter_Execute(self, image1)

# Register NotImageFilter in _SimpleITK:
_SimpleITK.NotImageFilter_swigregister(NotImageFilter)

def Not(image1):
    r"""Not(Image image1) -> Image"""
    return _SimpleITK.Not(image1)
class ObjectnessMeasureImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ObjectnessMeasureImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ObjectnessMeasureImageFilter

    def __init__(self):
        r"""__init__(ObjectnessMeasureImageFilter self) -> ObjectnessMeasureImageFilter"""
        _SimpleITK.ObjectnessMeasureImageFilter_swiginit(self, _SimpleITK.new_ObjectnessMeasureImageFilter())

    def SetAlpha(self, Alpha):
        r"""SetAlpha(ObjectnessMeasureImageFilter self, double Alpha)"""
        return _SimpleITK.ObjectnessMeasureImageFilter_SetAlpha(self, Alpha)

    def GetAlpha(self):
        r"""GetAlpha(ObjectnessMeasureImageFilter self) -> double"""
        return _SimpleITK.ObjectnessMeasureImageFilter_GetAlpha(self)

    def SetBeta(self, Beta):
        r"""SetBeta(ObjectnessMeasureImageFilter self, double Beta)"""
        return _SimpleITK.ObjectnessMeasureImageFilter_SetBeta(self, Beta)

    def GetBeta(self):
        r"""GetBeta(ObjectnessMeasureImageFilter self) -> double"""
        return _SimpleITK.ObjectnessMeasureImageFilter_GetBeta(self)

    def SetGamma(self, Gamma):
        r"""SetGamma(ObjectnessMeasureImageFilter self, double Gamma)"""
        return _SimpleITK.ObjectnessMeasureImageFilter_SetGamma(self, Gamma)

    def GetGamma(self):
        r"""GetGamma(ObjectnessMeasureImageFilter self) -> double"""
        return _SimpleITK.ObjectnessMeasureImageFilter_GetGamma(self)

    def SetScaleObjectnessMeasure(self, ScaleObjectnessMeasure):
        r"""SetScaleObjectnessMeasure(ObjectnessMeasureImageFilter self, bool ScaleObjectnessMeasure)"""
        return _SimpleITK.ObjectnessMeasureImageFilter_SetScaleObjectnessMeasure(self, ScaleObjectnessMeasure)

    def ScaleObjectnessMeasureOn(self):
        r"""ScaleObjectnessMeasureOn(ObjectnessMeasureImageFilter self)"""
        return _SimpleITK.ObjectnessMeasureImageFilter_ScaleObjectnessMeasureOn(self)

    def ScaleObjectnessMeasureOff(self):
        r"""ScaleObjectnessMeasureOff(ObjectnessMeasureImageFilter self)"""
        return _SimpleITK.ObjectnessMeasureImageFilter_ScaleObjectnessMeasureOff(self)

    def GetScaleObjectnessMeasure(self):
        r"""GetScaleObjectnessMeasure(ObjectnessMeasureImageFilter self) -> bool"""
        return _SimpleITK.ObjectnessMeasureImageFilter_GetScaleObjectnessMeasure(self)

    def SetObjectDimension(self, ObjectDimension):
        r"""SetObjectDimension(ObjectnessMeasureImageFilter self, unsigned int ObjectDimension)"""
        return _SimpleITK.ObjectnessMeasureImageFilter_SetObjectDimension(self, ObjectDimension)

    def GetObjectDimension(self):
        r"""GetObjectDimension(ObjectnessMeasureImageFilter self) -> unsigned int"""
        return _SimpleITK.ObjectnessMeasureImageFilter_GetObjectDimension(self)

    def SetBrightObject(self, BrightObject):
        r"""SetBrightObject(ObjectnessMeasureImageFilter self, bool BrightObject)"""
        return _SimpleITK.ObjectnessMeasureImageFilter_SetBrightObject(self, BrightObject)

    def BrightObjectOn(self):
        r"""BrightObjectOn(ObjectnessMeasureImageFilter self)"""
        return _SimpleITK.ObjectnessMeasureImageFilter_BrightObjectOn(self)

    def BrightObjectOff(self):
        r"""BrightObjectOff(ObjectnessMeasureImageFilter self)"""
        return _SimpleITK.ObjectnessMeasureImageFilter_BrightObjectOff(self)

    def GetBrightObject(self):
        r"""GetBrightObject(ObjectnessMeasureImageFilter self) -> bool"""
        return _SimpleITK.ObjectnessMeasureImageFilter_GetBrightObject(self)

    def GetName(self):
        r"""GetName(ObjectnessMeasureImageFilter self) -> std::string"""
        return _SimpleITK.ObjectnessMeasureImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ObjectnessMeasureImageFilter self) -> std::string"""
        return _SimpleITK.ObjectnessMeasureImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ObjectnessMeasureImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ObjectnessMeasureImageFilter_Execute(self, image1)

# Register ObjectnessMeasureImageFilter in _SimpleITK:
_SimpleITK.ObjectnessMeasureImageFilter_swigregister(ObjectnessMeasureImageFilter)

def ObjectnessMeasure(image1, alpha=0.5, beta=0.5, gamma=5.0, scaleObjectnessMeasure=True, objectDimension=1, brightObject=True):
    r"""ObjectnessMeasure(Image image1, double alpha=0.5, double beta=0.5, double gamma=5.0, bool scaleObjectnessMeasure=True, unsigned int objectDimension=1, bool brightObject=True) -> Image"""
    return _SimpleITK.ObjectnessMeasure(image1, alpha, beta, gamma, scaleObjectnessMeasure, objectDimension, brightObject)
class OpeningByReconstructionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::OpeningByReconstructionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_OpeningByReconstructionImageFilter

    def __init__(self):
        r"""__init__(OpeningByReconstructionImageFilter self) -> OpeningByReconstructionImageFilter"""
        _SimpleITK.OpeningByReconstructionImageFilter_swiginit(self, _SimpleITK.new_OpeningByReconstructionImageFilter())

    def SetKernelRadius(self, *args):
        r"""
        SetKernelRadius(OpeningByReconstructionImageFilter self, VectorUInt32 KernelRadius)
        SetKernelRadius(OpeningByReconstructionImageFilter self, unsigned int value)
        """
        return _SimpleITK.OpeningByReconstructionImageFilter_SetKernelRadius(self, *args)

    def GetKernelRadius(self):
        r"""GetKernelRadius(OpeningByReconstructionImageFilter self) -> VectorUInt32"""
        return _SimpleITK.OpeningByReconstructionImageFilter_GetKernelRadius(self)

    def SetKernelType(self, KernelType):
        r"""SetKernelType(OpeningByReconstructionImageFilter self, slicer_itk::simple::KernelEnum KernelType)"""
        return _SimpleITK.OpeningByReconstructionImageFilter_SetKernelType(self, KernelType)

    def GetKernelType(self):
        r"""GetKernelType(OpeningByReconstructionImageFilter self) -> slicer_itk::simple::KernelEnum"""
        return _SimpleITK.OpeningByReconstructionImageFilter_GetKernelType(self)

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(OpeningByReconstructionImageFilter self, bool FullyConnected)"""
        return _SimpleITK.OpeningByReconstructionImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(OpeningByReconstructionImageFilter self)"""
        return _SimpleITK.OpeningByReconstructionImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(OpeningByReconstructionImageFilter self)"""
        return _SimpleITK.OpeningByReconstructionImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(OpeningByReconstructionImageFilter self) -> bool"""
        return _SimpleITK.OpeningByReconstructionImageFilter_GetFullyConnected(self)

    def SetPreserveIntensities(self, PreserveIntensities):
        r"""SetPreserveIntensities(OpeningByReconstructionImageFilter self, bool PreserveIntensities)"""
        return _SimpleITK.OpeningByReconstructionImageFilter_SetPreserveIntensities(self, PreserveIntensities)

    def PreserveIntensitiesOn(self):
        r"""PreserveIntensitiesOn(OpeningByReconstructionImageFilter self)"""
        return _SimpleITK.OpeningByReconstructionImageFilter_PreserveIntensitiesOn(self)

    def PreserveIntensitiesOff(self):
        r"""PreserveIntensitiesOff(OpeningByReconstructionImageFilter self)"""
        return _SimpleITK.OpeningByReconstructionImageFilter_PreserveIntensitiesOff(self)

    def GetPreserveIntensities(self):
        r"""GetPreserveIntensities(OpeningByReconstructionImageFilter self) -> bool"""
        return _SimpleITK.OpeningByReconstructionImageFilter_GetPreserveIntensities(self)

    def GetName(self):
        r"""GetName(OpeningByReconstructionImageFilter self) -> std::string"""
        return _SimpleITK.OpeningByReconstructionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(OpeningByReconstructionImageFilter self) -> std::string"""
        return _SimpleITK.OpeningByReconstructionImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(OpeningByReconstructionImageFilter self, Image image1) -> Image"""
        return _SimpleITK.OpeningByReconstructionImageFilter_Execute(self, image1)

# Register OpeningByReconstructionImageFilter in _SimpleITK:
_SimpleITK.OpeningByReconstructionImageFilter_swigregister(OpeningByReconstructionImageFilter)

def OpeningByReconstruction(*args, **kwargs):
    r"""OpeningByReconstruction(Image image1, VectorUInt32 kernelRadius=std::vector< uint32_t >(3, 1), slicer_itk::simple::KernelEnum kernelType=sitkBall, bool fullyConnected=False, bool preserveIntensities=False) -> Image"""
    return _SimpleITK.OpeningByReconstruction(*args, **kwargs)
class OrImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::OrImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_OrImageFilter

    def __init__(self):
        r"""__init__(OrImageFilter self) -> OrImageFilter"""
        _SimpleITK.OrImageFilter_swiginit(self, _SimpleITK.new_OrImageFilter())

    def GetName(self):
        r"""GetName(OrImageFilter self) -> std::string"""
        return _SimpleITK.OrImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(OrImageFilter self) -> std::string"""
        return _SimpleITK.OrImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(OrImageFilter self, Image image1, Image image2) -> Image
        Execute(OrImageFilter self, Image image1, int constant) -> Image
        Execute(OrImageFilter self, int constant, Image image2) -> Image
        """
        return _SimpleITK.OrImageFilter_Execute(self, *args)

# Register OrImageFilter in _SimpleITK:
_SimpleITK.OrImageFilter_swigregister(OrImageFilter)

def Or(*args):
    r"""
    Or(Image image1, Image image2) -> Image
    Or(Image image1, int constant) -> Image
    Or(int constant, Image image2) -> Image
    """
    return _SimpleITK.Or(*args)
class OtsuMultipleThresholdsImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::OtsuMultipleThresholdsImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_OtsuMultipleThresholdsImageFilter

    def __init__(self):
        r"""__init__(OtsuMultipleThresholdsImageFilter self) -> OtsuMultipleThresholdsImageFilter"""
        _SimpleITK.OtsuMultipleThresholdsImageFilter_swiginit(self, _SimpleITK.new_OtsuMultipleThresholdsImageFilter())

    def SetNumberOfThresholds(self, NumberOfThresholds):
        r"""SetNumberOfThresholds(OtsuMultipleThresholdsImageFilter self, uint8_t NumberOfThresholds)"""
        return _SimpleITK.OtsuMultipleThresholdsImageFilter_SetNumberOfThresholds(self, NumberOfThresholds)

    def GetNumberOfThresholds(self):
        r"""GetNumberOfThresholds(OtsuMultipleThresholdsImageFilter self) -> uint8_t"""
        return _SimpleITK.OtsuMultipleThresholdsImageFilter_GetNumberOfThresholds(self)

    def SetLabelOffset(self, LabelOffset):
        r"""SetLabelOffset(OtsuMultipleThresholdsImageFilter self, uint8_t LabelOffset)"""
        return _SimpleITK.OtsuMultipleThresholdsImageFilter_SetLabelOffset(self, LabelOffset)

    def GetLabelOffset(self):
        r"""GetLabelOffset(OtsuMultipleThresholdsImageFilter self) -> uint8_t"""
        return _SimpleITK.OtsuMultipleThresholdsImageFilter_GetLabelOffset(self)

    def SetNumberOfHistogramBins(self, NumberOfHistogramBins):
        r"""SetNumberOfHistogramBins(OtsuMultipleThresholdsImageFilter self, uint32_t NumberOfHistogramBins)"""
        return _SimpleITK.OtsuMultipleThresholdsImageFilter_SetNumberOfHistogramBins(self, NumberOfHistogramBins)

    def GetNumberOfHistogramBins(self):
        r"""GetNumberOfHistogramBins(OtsuMultipleThresholdsImageFilter self) -> uint32_t"""
        return _SimpleITK.OtsuMultipleThresholdsImageFilter_GetNumberOfHistogramBins(self)

    def SetValleyEmphasis(self, ValleyEmphasis):
        r"""SetValleyEmphasis(OtsuMultipleThresholdsImageFilter self, bool ValleyEmphasis)"""
        return _SimpleITK.OtsuMultipleThresholdsImageFilter_SetValleyEmphasis(self, ValleyEmphasis)

    def ValleyEmphasisOn(self):
        r"""ValleyEmphasisOn(OtsuMultipleThresholdsImageFilter self)"""
        return _SimpleITK.OtsuMultipleThresholdsImageFilter_ValleyEmphasisOn(self)

    def ValleyEmphasisOff(self):
        r"""ValleyEmphasisOff(OtsuMultipleThresholdsImageFilter self)"""
        return _SimpleITK.OtsuMultipleThresholdsImageFilter_ValleyEmphasisOff(self)

    def GetValleyEmphasis(self):
        r"""GetValleyEmphasis(OtsuMultipleThresholdsImageFilter self) -> bool"""
        return _SimpleITK.OtsuMultipleThresholdsImageFilter_GetValleyEmphasis(self)

    def SetReturnBinMidpoint(self, ReturnBinMidpoint):
        r"""SetReturnBinMidpoint(OtsuMultipleThresholdsImageFilter self, bool ReturnBinMidpoint)"""
        return _SimpleITK.OtsuMultipleThresholdsImageFilter_SetReturnBinMidpoint(self, ReturnBinMidpoint)

    def ReturnBinMidpointOn(self):
        r"""ReturnBinMidpointOn(OtsuMultipleThresholdsImageFilter self)"""
        return _SimpleITK.OtsuMultipleThresholdsImageFilter_ReturnBinMidpointOn(self)

    def ReturnBinMidpointOff(self):
        r"""ReturnBinMidpointOff(OtsuMultipleThresholdsImageFilter self)"""
        return _SimpleITK.OtsuMultipleThresholdsImageFilter_ReturnBinMidpointOff(self)

    def GetReturnBinMidpoint(self):
        r"""GetReturnBinMidpoint(OtsuMultipleThresholdsImageFilter self) -> bool"""
        return _SimpleITK.OtsuMultipleThresholdsImageFilter_GetReturnBinMidpoint(self)

    def GetThresholds(self):
        r"""GetThresholds(OtsuMultipleThresholdsImageFilter self) -> VectorDouble"""
        return _SimpleITK.OtsuMultipleThresholdsImageFilter_GetThresholds(self)

    def GetName(self):
        r"""GetName(OtsuMultipleThresholdsImageFilter self) -> std::string"""
        return _SimpleITK.OtsuMultipleThresholdsImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(OtsuMultipleThresholdsImageFilter self) -> std::string"""
        return _SimpleITK.OtsuMultipleThresholdsImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(OtsuMultipleThresholdsImageFilter self, Image image1) -> Image"""
        return _SimpleITK.OtsuMultipleThresholdsImageFilter_Execute(self, image1)

# Register OtsuMultipleThresholdsImageFilter in _SimpleITK:
_SimpleITK.OtsuMultipleThresholdsImageFilter_swigregister(OtsuMultipleThresholdsImageFilter)

def OtsuMultipleThresholds(image1, numberOfThresholds=1, labelOffset=0, numberOfHistogramBins=128, valleyEmphasis=False, returnBinMidpoint=False):
    r"""OtsuMultipleThresholds(Image image1, uint8_t numberOfThresholds=1, uint8_t labelOffset=0, uint32_t numberOfHistogramBins=128, bool valleyEmphasis=False, bool returnBinMidpoint=False) -> Image"""
    return _SimpleITK.OtsuMultipleThresholds(image1, numberOfThresholds, labelOffset, numberOfHistogramBins, valleyEmphasis, returnBinMidpoint)
class OtsuThresholdImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::OtsuThresholdImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_OtsuThresholdImageFilter

    def __init__(self):
        r"""__init__(OtsuThresholdImageFilter self) -> OtsuThresholdImageFilter"""
        _SimpleITK.OtsuThresholdImageFilter_swiginit(self, _SimpleITK.new_OtsuThresholdImageFilter())

    def SetInsideValue(self, InsideValue):
        r"""SetInsideValue(OtsuThresholdImageFilter self, uint8_t InsideValue)"""
        return _SimpleITK.OtsuThresholdImageFilter_SetInsideValue(self, InsideValue)

    def GetInsideValue(self):
        r"""GetInsideValue(OtsuThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.OtsuThresholdImageFilter_GetInsideValue(self)

    def SetOutsideValue(self, OutsideValue):
        r"""SetOutsideValue(OtsuThresholdImageFilter self, uint8_t OutsideValue)"""
        return _SimpleITK.OtsuThresholdImageFilter_SetOutsideValue(self, OutsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(OtsuThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.OtsuThresholdImageFilter_GetOutsideValue(self)

    def SetNumberOfHistogramBins(self, NumberOfHistogramBins):
        r"""SetNumberOfHistogramBins(OtsuThresholdImageFilter self, uint32_t NumberOfHistogramBins)"""
        return _SimpleITK.OtsuThresholdImageFilter_SetNumberOfHistogramBins(self, NumberOfHistogramBins)

    def GetNumberOfHistogramBins(self):
        r"""GetNumberOfHistogramBins(OtsuThresholdImageFilter self) -> uint32_t"""
        return _SimpleITK.OtsuThresholdImageFilter_GetNumberOfHistogramBins(self)

    def SetMaskOutput(self, MaskOutput):
        r"""SetMaskOutput(OtsuThresholdImageFilter self, bool MaskOutput)"""
        return _SimpleITK.OtsuThresholdImageFilter_SetMaskOutput(self, MaskOutput)

    def MaskOutputOn(self):
        r"""MaskOutputOn(OtsuThresholdImageFilter self)"""
        return _SimpleITK.OtsuThresholdImageFilter_MaskOutputOn(self)

    def MaskOutputOff(self):
        r"""MaskOutputOff(OtsuThresholdImageFilter self)"""
        return _SimpleITK.OtsuThresholdImageFilter_MaskOutputOff(self)

    def GetMaskOutput(self):
        r"""GetMaskOutput(OtsuThresholdImageFilter self) -> bool"""
        return _SimpleITK.OtsuThresholdImageFilter_GetMaskOutput(self)

    def SetMaskValue(self, MaskValue):
        r"""SetMaskValue(OtsuThresholdImageFilter self, uint8_t MaskValue)"""
        return _SimpleITK.OtsuThresholdImageFilter_SetMaskValue(self, MaskValue)

    def GetMaskValue(self):
        r"""GetMaskValue(OtsuThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.OtsuThresholdImageFilter_GetMaskValue(self)

    def SetReturnBinMidpoint(self, ReturnBinMidpoint):
        r"""SetReturnBinMidpoint(OtsuThresholdImageFilter self, bool ReturnBinMidpoint)"""
        return _SimpleITK.OtsuThresholdImageFilter_SetReturnBinMidpoint(self, ReturnBinMidpoint)

    def ReturnBinMidpointOn(self):
        r"""ReturnBinMidpointOn(OtsuThresholdImageFilter self)"""
        return _SimpleITK.OtsuThresholdImageFilter_ReturnBinMidpointOn(self)

    def ReturnBinMidpointOff(self):
        r"""ReturnBinMidpointOff(OtsuThresholdImageFilter self)"""
        return _SimpleITK.OtsuThresholdImageFilter_ReturnBinMidpointOff(self)

    def GetReturnBinMidpoint(self):
        r"""GetReturnBinMidpoint(OtsuThresholdImageFilter self) -> bool"""
        return _SimpleITK.OtsuThresholdImageFilter_GetReturnBinMidpoint(self)

    def GetThreshold(self):
        r"""GetThreshold(OtsuThresholdImageFilter self) -> double"""
        return _SimpleITK.OtsuThresholdImageFilter_GetThreshold(self)

    def GetName(self):
        r"""GetName(OtsuThresholdImageFilter self) -> std::string"""
        return _SimpleITK.OtsuThresholdImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(OtsuThresholdImageFilter self) -> std::string"""
        return _SimpleITK.OtsuThresholdImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(OtsuThresholdImageFilter self, Image image, Image maskImage) -> Image
        Execute(OtsuThresholdImageFilter self, Image image) -> Image
        """
        return _SimpleITK.OtsuThresholdImageFilter_Execute(self, *args)

# Register OtsuThresholdImageFilter in _SimpleITK:
_SimpleITK.OtsuThresholdImageFilter_swigregister(OtsuThresholdImageFilter)

def OtsuThreshold(*args):
    r"""
    OtsuThreshold(Image image, Image maskImage, uint8_t insideValue=1, uint8_t outsideValue=0, uint32_t numberOfHistogramBins=128, bool maskOutput=True, uint8_t maskValue=255, bool returnBinMidpoint=False) -> Image
    OtsuThreshold(Image image, uint8_t insideValue=1, uint8_t outsideValue=0, uint32_t numberOfHistogramBins=128, bool maskOutput=True, uint8_t maskValue=255, bool returnBinMidpoint=False) -> Image
    """
    return _SimpleITK.OtsuThreshold(*args)
class PatchBasedDenoisingImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::PatchBasedDenoisingImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_PatchBasedDenoisingImageFilter

    def __init__(self):
        r"""__init__(PatchBasedDenoisingImageFilter self) -> PatchBasedDenoisingImageFilter"""
        _SimpleITK.PatchBasedDenoisingImageFilter_swiginit(self, _SimpleITK.new_PatchBasedDenoisingImageFilter())

    def SetKernelBandwidthSigma(self, KernelBandwidthSigma):
        r"""SetKernelBandwidthSigma(PatchBasedDenoisingImageFilter self, double KernelBandwidthSigma)"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_SetKernelBandwidthSigma(self, KernelBandwidthSigma)

    def GetKernelBandwidthSigma(self):
        r"""GetKernelBandwidthSigma(PatchBasedDenoisingImageFilter self) -> double"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_GetKernelBandwidthSigma(self)

    def SetPatchRadius(self, PatchRadius):
        r"""SetPatchRadius(PatchBasedDenoisingImageFilter self, uint32_t PatchRadius)"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_SetPatchRadius(self, PatchRadius)

    def GetPatchRadius(self):
        r"""GetPatchRadius(PatchBasedDenoisingImageFilter self) -> uint32_t"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_GetPatchRadius(self)

    def SetNumberOfIterations(self, NumberOfIterations):
        r"""SetNumberOfIterations(PatchBasedDenoisingImageFilter self, uint32_t NumberOfIterations)"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_SetNumberOfIterations(self, NumberOfIterations)

    def GetNumberOfIterations(self):
        r"""GetNumberOfIterations(PatchBasedDenoisingImageFilter self) -> uint32_t"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_GetNumberOfIterations(self)

    def SetNumberOfSamplePatches(self, NumberOfSamplePatches):
        r"""SetNumberOfSamplePatches(PatchBasedDenoisingImageFilter self, uint32_t NumberOfSamplePatches)"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_SetNumberOfSamplePatches(self, NumberOfSamplePatches)

    def GetNumberOfSamplePatches(self):
        r"""GetNumberOfSamplePatches(PatchBasedDenoisingImageFilter self) -> uint32_t"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_GetNumberOfSamplePatches(self)

    def SetSampleVariance(self, SampleVariance):
        r"""SetSampleVariance(PatchBasedDenoisingImageFilter self, double SampleVariance)"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_SetSampleVariance(self, SampleVariance)

    def GetSampleVariance(self):
        r"""GetSampleVariance(PatchBasedDenoisingImageFilter self) -> double"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_GetSampleVariance(self)
    NOMODEL = _SimpleITK.PatchBasedDenoisingImageFilter_NOMODEL
    
    GAUSSIAN = _SimpleITK.PatchBasedDenoisingImageFilter_GAUSSIAN
    
    RICIAN = _SimpleITK.PatchBasedDenoisingImageFilter_RICIAN
    
    POISSON = _SimpleITK.PatchBasedDenoisingImageFilter_POISSON
    

    def SetNoiseModel(self, NoiseModel):
        r"""SetNoiseModel(PatchBasedDenoisingImageFilter self, slicer_itk::simple::PatchBasedDenoisingImageFilter::NoiseModelType NoiseModel)"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_SetNoiseModel(self, NoiseModel)

    def GetNoiseModel(self):
        r"""GetNoiseModel(PatchBasedDenoisingImageFilter self) -> slicer_itk::simple::PatchBasedDenoisingImageFilter::NoiseModelType"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_GetNoiseModel(self)

    def SetNoiseSigma(self, NoiseSigma):
        r"""SetNoiseSigma(PatchBasedDenoisingImageFilter self, double NoiseSigma)"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_SetNoiseSigma(self, NoiseSigma)

    def GetNoiseSigma(self):
        r"""GetNoiseSigma(PatchBasedDenoisingImageFilter self) -> double"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_GetNoiseSigma(self)

    def SetNoiseModelFidelityWeight(self, NoiseModelFidelityWeight):
        r"""SetNoiseModelFidelityWeight(PatchBasedDenoisingImageFilter self, double NoiseModelFidelityWeight)"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_SetNoiseModelFidelityWeight(self, NoiseModelFidelityWeight)

    def GetNoiseModelFidelityWeight(self):
        r"""GetNoiseModelFidelityWeight(PatchBasedDenoisingImageFilter self) -> double"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_GetNoiseModelFidelityWeight(self)

    def SetAlwaysTreatComponentsAsEuclidean(self, AlwaysTreatComponentsAsEuclidean):
        r"""SetAlwaysTreatComponentsAsEuclidean(PatchBasedDenoisingImageFilter self, bool AlwaysTreatComponentsAsEuclidean)"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_SetAlwaysTreatComponentsAsEuclidean(self, AlwaysTreatComponentsAsEuclidean)

    def AlwaysTreatComponentsAsEuclideanOn(self):
        r"""AlwaysTreatComponentsAsEuclideanOn(PatchBasedDenoisingImageFilter self)"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_AlwaysTreatComponentsAsEuclideanOn(self)

    def AlwaysTreatComponentsAsEuclideanOff(self):
        r"""AlwaysTreatComponentsAsEuclideanOff(PatchBasedDenoisingImageFilter self)"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_AlwaysTreatComponentsAsEuclideanOff(self)

    def GetAlwaysTreatComponentsAsEuclidean(self):
        r"""GetAlwaysTreatComponentsAsEuclidean(PatchBasedDenoisingImageFilter self) -> bool"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_GetAlwaysTreatComponentsAsEuclidean(self)

    def SetKernelBandwidthEstimation(self, KernelBandwidthEstimation):
        r"""SetKernelBandwidthEstimation(PatchBasedDenoisingImageFilter self, bool KernelBandwidthEstimation)"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_SetKernelBandwidthEstimation(self, KernelBandwidthEstimation)

    def KernelBandwidthEstimationOn(self):
        r"""KernelBandwidthEstimationOn(PatchBasedDenoisingImageFilter self)"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_KernelBandwidthEstimationOn(self)

    def KernelBandwidthEstimationOff(self):
        r"""KernelBandwidthEstimationOff(PatchBasedDenoisingImageFilter self)"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_KernelBandwidthEstimationOff(self)

    def GetKernelBandwidthEstimation(self):
        r"""GetKernelBandwidthEstimation(PatchBasedDenoisingImageFilter self) -> bool"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_GetKernelBandwidthEstimation(self)

    def SetKernelBandwidthMultiplicationFactor(self, KernelBandwidthMultiplicationFactor):
        r"""SetKernelBandwidthMultiplicationFactor(PatchBasedDenoisingImageFilter self, double KernelBandwidthMultiplicationFactor)"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_SetKernelBandwidthMultiplicationFactor(self, KernelBandwidthMultiplicationFactor)

    def GetKernelBandwidthMultiplicationFactor(self):
        r"""GetKernelBandwidthMultiplicationFactor(PatchBasedDenoisingImageFilter self) -> double"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_GetKernelBandwidthMultiplicationFactor(self)

    def SetKernelBandwidthUpdateFrequency(self, KernelBandwidthUpdateFrequency):
        r"""SetKernelBandwidthUpdateFrequency(PatchBasedDenoisingImageFilter self, uint32_t KernelBandwidthUpdateFrequency)"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_SetKernelBandwidthUpdateFrequency(self, KernelBandwidthUpdateFrequency)

    def GetKernelBandwidthUpdateFrequency(self):
        r"""GetKernelBandwidthUpdateFrequency(PatchBasedDenoisingImageFilter self) -> uint32_t"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_GetKernelBandwidthUpdateFrequency(self)

    def SetKernelBandwidthFractionPixelsForEstimation(self, KernelBandwidthFractionPixelsForEstimation):
        r"""SetKernelBandwidthFractionPixelsForEstimation(PatchBasedDenoisingImageFilter self, double KernelBandwidthFractionPixelsForEstimation)"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_SetKernelBandwidthFractionPixelsForEstimation(self, KernelBandwidthFractionPixelsForEstimation)

    def GetKernelBandwidthFractionPixelsForEstimation(self):
        r"""GetKernelBandwidthFractionPixelsForEstimation(PatchBasedDenoisingImageFilter self) -> double"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_GetKernelBandwidthFractionPixelsForEstimation(self)

    def GetName(self):
        r"""GetName(PatchBasedDenoisingImageFilter self) -> std::string"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(PatchBasedDenoisingImageFilter self) -> std::string"""
        return _SimpleITK.PatchBasedDenoisingImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(PatchBasedDenoisingImageFilter self, Image image1) -> Image"""
        return _SimpleITK.PatchBasedDenoisingImageFilter_Execute(self, image1)

# Register PatchBasedDenoisingImageFilter in _SimpleITK:
_SimpleITK.PatchBasedDenoisingImageFilter_swigregister(PatchBasedDenoisingImageFilter)
class PermuteAxesImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::PermuteAxesImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_PermuteAxesImageFilter

    def __init__(self):
        r"""__init__(PermuteAxesImageFilter self) -> PermuteAxesImageFilter"""
        _SimpleITK.PermuteAxesImageFilter_swiginit(self, _SimpleITK.new_PermuteAxesImageFilter())

    def SetOrder(self, Order):
        r"""SetOrder(PermuteAxesImageFilter self, VectorUInt32 Order)"""
        return _SimpleITK.PermuteAxesImageFilter_SetOrder(self, Order)

    def GetOrder(self):
        r"""GetOrder(PermuteAxesImageFilter self) -> VectorUInt32"""
        return _SimpleITK.PermuteAxesImageFilter_GetOrder(self)

    def GetName(self):
        r"""GetName(PermuteAxesImageFilter self) -> std::string"""
        return _SimpleITK.PermuteAxesImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(PermuteAxesImageFilter self) -> std::string"""
        return _SimpleITK.PermuteAxesImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(PermuteAxesImageFilter self, Image image1) -> Image"""
        return _SimpleITK.PermuteAxesImageFilter_Execute(self, image1)

# Register PermuteAxesImageFilter in _SimpleITK:
_SimpleITK.PermuteAxesImageFilter_swigregister(PermuteAxesImageFilter)
cvar = _SimpleITK.cvar
PermuteAxesImageFilter.DefaultOrder = _SimpleITK.cvar.PermuteAxesImageFilter_DefaultOrder


def PermuteAxes(*args, **kwargs):
    r"""PermuteAxes(Image image1, VectorUInt32 order=std::vector< unsigned int >(slicer_itk::simple::PermuteAxesImageFilter::DefaultOrder)) -> Image"""
    return _SimpleITK.PermuteAxes(*args, **kwargs)
class PhysicalPointImageSource(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::PhysicalPointImageSource class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_PhysicalPointImageSource

    def __init__(self):
        r"""__init__(PhysicalPointImageSource self) -> PhysicalPointImageSource"""
        _SimpleITK.PhysicalPointImageSource_swiginit(self, _SimpleITK.new_PhysicalPointImageSource())

    def SetOutputPixelType(self, OutputPixelType):
        r"""SetOutputPixelType(PhysicalPointImageSource self, slicer_itk::simple::PixelIDValueEnum OutputPixelType)"""
        return _SimpleITK.PhysicalPointImageSource_SetOutputPixelType(self, OutputPixelType)

    def GetOutputPixelType(self):
        r"""GetOutputPixelType(PhysicalPointImageSource self) -> slicer_itk::simple::PixelIDValueEnum"""
        return _SimpleITK.PhysicalPointImageSource_GetOutputPixelType(self)

    def SetSize(self, Size):
        r"""SetSize(PhysicalPointImageSource self, VectorUInt32 Size)"""
        return _SimpleITK.PhysicalPointImageSource_SetSize(self, Size)

    def GetSize(self):
        r"""GetSize(PhysicalPointImageSource self) -> VectorUInt32"""
        return _SimpleITK.PhysicalPointImageSource_GetSize(self)

    def SetOrigin(self, Origin):
        r"""SetOrigin(PhysicalPointImageSource self, VectorDouble Origin)"""
        return _SimpleITK.PhysicalPointImageSource_SetOrigin(self, Origin)

    def GetOrigin(self):
        r"""GetOrigin(PhysicalPointImageSource self) -> VectorDouble"""
        return _SimpleITK.PhysicalPointImageSource_GetOrigin(self)

    def SetSpacing(self, Spacing):
        r"""SetSpacing(PhysicalPointImageSource self, VectorDouble Spacing)"""
        return _SimpleITK.PhysicalPointImageSource_SetSpacing(self, Spacing)

    def GetSpacing(self):
        r"""GetSpacing(PhysicalPointImageSource self) -> VectorDouble"""
        return _SimpleITK.PhysicalPointImageSource_GetSpacing(self)

    def SetDirection(self, Direction):
        r"""SetDirection(PhysicalPointImageSource self, VectorDouble Direction)"""
        return _SimpleITK.PhysicalPointImageSource_SetDirection(self, Direction)

    def GetDirection(self):
        r"""GetDirection(PhysicalPointImageSource self) -> VectorDouble"""
        return _SimpleITK.PhysicalPointImageSource_GetDirection(self)

    def GetName(self):
        r"""GetName(PhysicalPointImageSource self) -> std::string"""
        return _SimpleITK.PhysicalPointImageSource_GetName(self)

    def __str__(self):
        r"""__str__(PhysicalPointImageSource self) -> std::string"""
        return _SimpleITK.PhysicalPointImageSource___str__(self)

    def Execute(self):
        r"""Execute(PhysicalPointImageSource self) -> Image"""
        return _SimpleITK.PhysicalPointImageSource_Execute(self)

    def SetReferenceImage(self, refImage):
        r"""SetReferenceImage(PhysicalPointImageSource self, Image refImage)"""
        return _SimpleITK.PhysicalPointImageSource_SetReferenceImage(self, refImage)

# Register PhysicalPointImageSource in _SimpleITK:
_SimpleITK.PhysicalPointImageSource_swigregister(PhysicalPointImageSource)

def PhysicalPointSource(*args, **kwargs):
    r"""PhysicalPointSource(slicer_itk::simple::PixelIDValueEnum outputPixelType=sitkVectorFloat32, VectorUInt32 size=std::vector< unsigned int >(3, 64), VectorDouble origin=std::vector< double >(3, 0.0), VectorDouble spacing=std::vector< double >(3, 1.0), VectorDouble direction=std::vector< double >()) -> Image"""
    return _SimpleITK.PhysicalPointSource(*args, **kwargs)
class PowImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::PowImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_PowImageFilter

    def __init__(self):
        r"""__init__(PowImageFilter self) -> PowImageFilter"""
        _SimpleITK.PowImageFilter_swiginit(self, _SimpleITK.new_PowImageFilter())

    def GetName(self):
        r"""GetName(PowImageFilter self) -> std::string"""
        return _SimpleITK.PowImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(PowImageFilter self) -> std::string"""
        return _SimpleITK.PowImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(PowImageFilter self, Image image1, Image image2) -> Image
        Execute(PowImageFilter self, Image image1, double constant) -> Image
        Execute(PowImageFilter self, double constant, Image image2) -> Image
        """
        return _SimpleITK.PowImageFilter_Execute(self, *args)

# Register PowImageFilter in _SimpleITK:
_SimpleITK.PowImageFilter_swigregister(PowImageFilter)

def Pow(*args):
    r"""
    Pow(Image image1, Image image2) -> Image
    Pow(Image image1, double constant) -> Image
    Pow(double constant, Image image2) -> Image
    """
    return _SimpleITK.Pow(*args)
class ProjectedLandweberDeconvolutionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ProjectedLandweberDeconvolutionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ProjectedLandweberDeconvolutionImageFilter

    def __init__(self):
        r"""__init__(ProjectedLandweberDeconvolutionImageFilter self) -> ProjectedLandweberDeconvolutionImageFilter"""
        _SimpleITK.ProjectedLandweberDeconvolutionImageFilter_swiginit(self, _SimpleITK.new_ProjectedLandweberDeconvolutionImageFilter())

    def SetAlpha(self, Alpha):
        r"""SetAlpha(ProjectedLandweberDeconvolutionImageFilter self, double Alpha)"""
        return _SimpleITK.ProjectedLandweberDeconvolutionImageFilter_SetAlpha(self, Alpha)

    def GetAlpha(self):
        r"""GetAlpha(ProjectedLandweberDeconvolutionImageFilter self) -> double"""
        return _SimpleITK.ProjectedLandweberDeconvolutionImageFilter_GetAlpha(self)

    def SetNumberOfIterations(self, NumberOfIterations):
        r"""SetNumberOfIterations(ProjectedLandweberDeconvolutionImageFilter self, int NumberOfIterations)"""
        return _SimpleITK.ProjectedLandweberDeconvolutionImageFilter_SetNumberOfIterations(self, NumberOfIterations)

    def GetNumberOfIterations(self):
        r"""GetNumberOfIterations(ProjectedLandweberDeconvolutionImageFilter self) -> int"""
        return _SimpleITK.ProjectedLandweberDeconvolutionImageFilter_GetNumberOfIterations(self)

    def SetNormalize(self, Normalize):
        r"""SetNormalize(ProjectedLandweberDeconvolutionImageFilter self, bool Normalize)"""
        return _SimpleITK.ProjectedLandweberDeconvolutionImageFilter_SetNormalize(self, Normalize)

    def NormalizeOn(self):
        r"""NormalizeOn(ProjectedLandweberDeconvolutionImageFilter self)"""
        return _SimpleITK.ProjectedLandweberDeconvolutionImageFilter_NormalizeOn(self)

    def NormalizeOff(self):
        r"""NormalizeOff(ProjectedLandweberDeconvolutionImageFilter self)"""
        return _SimpleITK.ProjectedLandweberDeconvolutionImageFilter_NormalizeOff(self)

    def GetNormalize(self):
        r"""GetNormalize(ProjectedLandweberDeconvolutionImageFilter self) -> bool"""
        return _SimpleITK.ProjectedLandweberDeconvolutionImageFilter_GetNormalize(self)
    ZERO_PAD = _SimpleITK.ProjectedLandweberDeconvolutionImageFilter_ZERO_PAD
    
    ZERO_FLUX_NEUMANN_PAD = _SimpleITK.ProjectedLandweberDeconvolutionImageFilter_ZERO_FLUX_NEUMANN_PAD
    
    PERIODIC_PAD = _SimpleITK.ProjectedLandweberDeconvolutionImageFilter_PERIODIC_PAD
    

    def SetBoundaryCondition(self, BoundaryCondition):
        r"""SetBoundaryCondition(ProjectedLandweberDeconvolutionImageFilter self, slicer_itk::simple::ProjectedLandweberDeconvolutionImageFilter::BoundaryConditionType BoundaryCondition)"""
        return _SimpleITK.ProjectedLandweberDeconvolutionImageFilter_SetBoundaryCondition(self, BoundaryCondition)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(ProjectedLandweberDeconvolutionImageFilter self) -> slicer_itk::simple::ProjectedLandweberDeconvolutionImageFilter::BoundaryConditionType"""
        return _SimpleITK.ProjectedLandweberDeconvolutionImageFilter_GetBoundaryCondition(self)
    SAME = _SimpleITK.ProjectedLandweberDeconvolutionImageFilter_SAME
    
    VALID = _SimpleITK.ProjectedLandweberDeconvolutionImageFilter_VALID
    

    def SetOutputRegionMode(self, OutputRegionMode):
        r"""SetOutputRegionMode(ProjectedLandweberDeconvolutionImageFilter self, slicer_itk::simple::ProjectedLandweberDeconvolutionImageFilter::OutputRegionModeType OutputRegionMode)"""
        return _SimpleITK.ProjectedLandweberDeconvolutionImageFilter_SetOutputRegionMode(self, OutputRegionMode)

    def GetOutputRegionMode(self):
        r"""GetOutputRegionMode(ProjectedLandweberDeconvolutionImageFilter self) -> slicer_itk::simple::ProjectedLandweberDeconvolutionImageFilter::OutputRegionModeType"""
        return _SimpleITK.ProjectedLandweberDeconvolutionImageFilter_GetOutputRegionMode(self)

    def GetName(self):
        r"""GetName(ProjectedLandweberDeconvolutionImageFilter self) -> std::string"""
        return _SimpleITK.ProjectedLandweberDeconvolutionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ProjectedLandweberDeconvolutionImageFilter self) -> std::string"""
        return _SimpleITK.ProjectedLandweberDeconvolutionImageFilter___str__(self)

    def Execute(self, image1, image2):
        r"""Execute(ProjectedLandweberDeconvolutionImageFilter self, Image image1, Image image2) -> Image"""
        return _SimpleITK.ProjectedLandweberDeconvolutionImageFilter_Execute(self, image1, image2)

# Register ProjectedLandweberDeconvolutionImageFilter in _SimpleITK:
_SimpleITK.ProjectedLandweberDeconvolutionImageFilter_swigregister(ProjectedLandweberDeconvolutionImageFilter)

def ProjectedLandweberDeconvolution(*args, **kwargs):
    r"""ProjectedLandweberDeconvolution(Image image1, Image image2, double alpha=0.1, int numberOfIterations=1, bool normalize=False, slicer_itk::simple::ProjectedLandweberDeconvolutionImageFilter::BoundaryConditionType boundaryCondition=ZERO_FLUX_NEUMANN_PAD, slicer_itk::simple::ProjectedLandweberDeconvolutionImageFilter::OutputRegionModeType outputRegionMode=SAME) -> Image"""
    return _SimpleITK.ProjectedLandweberDeconvolution(*args, **kwargs)
class RankImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::RankImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_RankImageFilter

    def __init__(self):
        r"""__init__(RankImageFilter self) -> RankImageFilter"""
        _SimpleITK.RankImageFilter_swiginit(self, _SimpleITK.new_RankImageFilter())

    def SetRank(self, Rank):
        r"""SetRank(RankImageFilter self, double Rank)"""
        return _SimpleITK.RankImageFilter_SetRank(self, Rank)

    def GetRank(self):
        r"""GetRank(RankImageFilter self) -> double"""
        return _SimpleITK.RankImageFilter_GetRank(self)

    def SetRadius(self, Radius):
        r"""SetRadius(RankImageFilter self, VectorUInt32 Radius)"""
        return _SimpleITK.RankImageFilter_SetRadius(self, Radius)

    def GetRadius(self):
        r"""GetRadius(RankImageFilter self) -> VectorUInt32"""
        return _SimpleITK.RankImageFilter_GetRadius(self)

    def SetKernelType(self, KernelType):
        r"""SetKernelType(RankImageFilter self, slicer_itk::simple::KernelEnum KernelType)"""
        return _SimpleITK.RankImageFilter_SetKernelType(self, KernelType)

    def GetKernelType(self):
        r"""GetKernelType(RankImageFilter self) -> slicer_itk::simple::KernelEnum"""
        return _SimpleITK.RankImageFilter_GetKernelType(self)

    def GetName(self):
        r"""GetName(RankImageFilter self) -> std::string"""
        return _SimpleITK.RankImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(RankImageFilter self) -> std::string"""
        return _SimpleITK.RankImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(RankImageFilter self, Image image1) -> Image"""
        return _SimpleITK.RankImageFilter_Execute(self, image1)

# Register RankImageFilter in _SimpleITK:
_SimpleITK.RankImageFilter_swigregister(RankImageFilter)

def Rank(*args, **kwargs):
    r"""Rank(Image image1, double rank=0.5, VectorUInt32 radius=std::vector< unsigned int >(3, 1), slicer_itk::simple::KernelEnum kernelType=sitkBox) -> Image"""
    return _SimpleITK.Rank(*args, **kwargs)
class RealAndImaginaryToComplexImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::RealAndImaginaryToComplexImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_RealAndImaginaryToComplexImageFilter

    def __init__(self):
        r"""__init__(RealAndImaginaryToComplexImageFilter self) -> RealAndImaginaryToComplexImageFilter"""
        _SimpleITK.RealAndImaginaryToComplexImageFilter_swiginit(self, _SimpleITK.new_RealAndImaginaryToComplexImageFilter())

    def GetName(self):
        r"""GetName(RealAndImaginaryToComplexImageFilter self) -> std::string"""
        return _SimpleITK.RealAndImaginaryToComplexImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(RealAndImaginaryToComplexImageFilter self) -> std::string"""
        return _SimpleITK.RealAndImaginaryToComplexImageFilter___str__(self)

    def Execute(self, image1, image2):
        r"""Execute(RealAndImaginaryToComplexImageFilter self, Image image1, Image image2) -> Image"""
        return _SimpleITK.RealAndImaginaryToComplexImageFilter_Execute(self, image1, image2)

# Register RealAndImaginaryToComplexImageFilter in _SimpleITK:
_SimpleITK.RealAndImaginaryToComplexImageFilter_swigregister(RealAndImaginaryToComplexImageFilter)

def RealAndImaginaryToComplex(image1, image2):
    r"""RealAndImaginaryToComplex(Image image1, Image image2) -> Image"""
    return _SimpleITK.RealAndImaginaryToComplex(image1, image2)
class RealToHalfHermitianForwardFFTImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::RealToHalfHermitianForwardFFTImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_RealToHalfHermitianForwardFFTImageFilter

    def __init__(self):
        r"""__init__(RealToHalfHermitianForwardFFTImageFilter self) -> RealToHalfHermitianForwardFFTImageFilter"""
        _SimpleITK.RealToHalfHermitianForwardFFTImageFilter_swiginit(self, _SimpleITK.new_RealToHalfHermitianForwardFFTImageFilter())

    def GetName(self):
        r"""GetName(RealToHalfHermitianForwardFFTImageFilter self) -> std::string"""
        return _SimpleITK.RealToHalfHermitianForwardFFTImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(RealToHalfHermitianForwardFFTImageFilter self) -> std::string"""
        return _SimpleITK.RealToHalfHermitianForwardFFTImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(RealToHalfHermitianForwardFFTImageFilter self, Image image1) -> Image"""
        return _SimpleITK.RealToHalfHermitianForwardFFTImageFilter_Execute(self, image1)

# Register RealToHalfHermitianForwardFFTImageFilter in _SimpleITK:
_SimpleITK.RealToHalfHermitianForwardFFTImageFilter_swigregister(RealToHalfHermitianForwardFFTImageFilter)

def RealToHalfHermitianForwardFFT(image1):
    r"""RealToHalfHermitianForwardFFT(Image image1) -> Image"""
    return _SimpleITK.RealToHalfHermitianForwardFFT(image1)
class ReconstructionByDilationImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ReconstructionByDilationImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ReconstructionByDilationImageFilter

    def __init__(self):
        r"""__init__(ReconstructionByDilationImageFilter self) -> ReconstructionByDilationImageFilter"""
        _SimpleITK.ReconstructionByDilationImageFilter_swiginit(self, _SimpleITK.new_ReconstructionByDilationImageFilter())

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(ReconstructionByDilationImageFilter self, bool FullyConnected)"""
        return _SimpleITK.ReconstructionByDilationImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(ReconstructionByDilationImageFilter self)"""
        return _SimpleITK.ReconstructionByDilationImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(ReconstructionByDilationImageFilter self)"""
        return _SimpleITK.ReconstructionByDilationImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(ReconstructionByDilationImageFilter self) -> bool"""
        return _SimpleITK.ReconstructionByDilationImageFilter_GetFullyConnected(self)

    def SetUseInternalCopy(self, UseInternalCopy):
        r"""SetUseInternalCopy(ReconstructionByDilationImageFilter self, bool UseInternalCopy)"""
        return _SimpleITK.ReconstructionByDilationImageFilter_SetUseInternalCopy(self, UseInternalCopy)

    def UseInternalCopyOn(self):
        r"""UseInternalCopyOn(ReconstructionByDilationImageFilter self)"""
        return _SimpleITK.ReconstructionByDilationImageFilter_UseInternalCopyOn(self)

    def UseInternalCopyOff(self):
        r"""UseInternalCopyOff(ReconstructionByDilationImageFilter self)"""
        return _SimpleITK.ReconstructionByDilationImageFilter_UseInternalCopyOff(self)

    def GetUseInternalCopy(self):
        r"""GetUseInternalCopy(ReconstructionByDilationImageFilter self) -> bool"""
        return _SimpleITK.ReconstructionByDilationImageFilter_GetUseInternalCopy(self)

    def GetName(self):
        r"""GetName(ReconstructionByDilationImageFilter self) -> std::string"""
        return _SimpleITK.ReconstructionByDilationImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ReconstructionByDilationImageFilter self) -> std::string"""
        return _SimpleITK.ReconstructionByDilationImageFilter___str__(self)

    def Execute(self, markerImage, maskImage):
        r"""Execute(ReconstructionByDilationImageFilter self, Image markerImage, Image maskImage) -> Image"""
        return _SimpleITK.ReconstructionByDilationImageFilter_Execute(self, markerImage, maskImage)

# Register ReconstructionByDilationImageFilter in _SimpleITK:
_SimpleITK.ReconstructionByDilationImageFilter_swigregister(ReconstructionByDilationImageFilter)

def ReconstructionByDilation(markerImage, maskImage, fullyConnected=False, useInternalCopy=True):
    r"""ReconstructionByDilation(Image markerImage, Image maskImage, bool fullyConnected=False, bool useInternalCopy=True) -> Image"""
    return _SimpleITK.ReconstructionByDilation(markerImage, maskImage, fullyConnected, useInternalCopy)
class ReconstructionByErosionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ReconstructionByErosionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ReconstructionByErosionImageFilter

    def __init__(self):
        r"""__init__(ReconstructionByErosionImageFilter self) -> ReconstructionByErosionImageFilter"""
        _SimpleITK.ReconstructionByErosionImageFilter_swiginit(self, _SimpleITK.new_ReconstructionByErosionImageFilter())

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(ReconstructionByErosionImageFilter self, bool FullyConnected)"""
        return _SimpleITK.ReconstructionByErosionImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(ReconstructionByErosionImageFilter self)"""
        return _SimpleITK.ReconstructionByErosionImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(ReconstructionByErosionImageFilter self)"""
        return _SimpleITK.ReconstructionByErosionImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(ReconstructionByErosionImageFilter self) -> bool"""
        return _SimpleITK.ReconstructionByErosionImageFilter_GetFullyConnected(self)

    def SetUseInternalCopy(self, UseInternalCopy):
        r"""SetUseInternalCopy(ReconstructionByErosionImageFilter self, bool UseInternalCopy)"""
        return _SimpleITK.ReconstructionByErosionImageFilter_SetUseInternalCopy(self, UseInternalCopy)

    def UseInternalCopyOn(self):
        r"""UseInternalCopyOn(ReconstructionByErosionImageFilter self)"""
        return _SimpleITK.ReconstructionByErosionImageFilter_UseInternalCopyOn(self)

    def UseInternalCopyOff(self):
        r"""UseInternalCopyOff(ReconstructionByErosionImageFilter self)"""
        return _SimpleITK.ReconstructionByErosionImageFilter_UseInternalCopyOff(self)

    def GetUseInternalCopy(self):
        r"""GetUseInternalCopy(ReconstructionByErosionImageFilter self) -> bool"""
        return _SimpleITK.ReconstructionByErosionImageFilter_GetUseInternalCopy(self)

    def GetName(self):
        r"""GetName(ReconstructionByErosionImageFilter self) -> std::string"""
        return _SimpleITK.ReconstructionByErosionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ReconstructionByErosionImageFilter self) -> std::string"""
        return _SimpleITK.ReconstructionByErosionImageFilter___str__(self)

    def Execute(self, markerImage, maskImage):
        r"""Execute(ReconstructionByErosionImageFilter self, Image markerImage, Image maskImage) -> Image"""
        return _SimpleITK.ReconstructionByErosionImageFilter_Execute(self, markerImage, maskImage)

# Register ReconstructionByErosionImageFilter in _SimpleITK:
_SimpleITK.ReconstructionByErosionImageFilter_swigregister(ReconstructionByErosionImageFilter)

def ReconstructionByErosion(markerImage, maskImage, fullyConnected=False, useInternalCopy=True):
    r"""ReconstructionByErosion(Image markerImage, Image maskImage, bool fullyConnected=False, bool useInternalCopy=True) -> Image"""
    return _SimpleITK.ReconstructionByErosion(markerImage, maskImage, fullyConnected, useInternalCopy)
class RecursiveGaussianImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::RecursiveGaussianImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_RecursiveGaussianImageFilter

    def __init__(self):
        r"""__init__(RecursiveGaussianImageFilter self) -> RecursiveGaussianImageFilter"""
        _SimpleITK.RecursiveGaussianImageFilter_swiginit(self, _SimpleITK.new_RecursiveGaussianImageFilter())

    def SetSigma(self, Sigma):
        r"""SetSigma(RecursiveGaussianImageFilter self, double Sigma)"""
        return _SimpleITK.RecursiveGaussianImageFilter_SetSigma(self, Sigma)

    def GetSigma(self):
        r"""GetSigma(RecursiveGaussianImageFilter self) -> double"""
        return _SimpleITK.RecursiveGaussianImageFilter_GetSigma(self)

    def SetNormalizeAcrossScale(self, NormalizeAcrossScale):
        r"""SetNormalizeAcrossScale(RecursiveGaussianImageFilter self, bool NormalizeAcrossScale)"""
        return _SimpleITK.RecursiveGaussianImageFilter_SetNormalizeAcrossScale(self, NormalizeAcrossScale)

    def NormalizeAcrossScaleOn(self):
        r"""NormalizeAcrossScaleOn(RecursiveGaussianImageFilter self)"""
        return _SimpleITK.RecursiveGaussianImageFilter_NormalizeAcrossScaleOn(self)

    def NormalizeAcrossScaleOff(self):
        r"""NormalizeAcrossScaleOff(RecursiveGaussianImageFilter self)"""
        return _SimpleITK.RecursiveGaussianImageFilter_NormalizeAcrossScaleOff(self)

    def GetNormalizeAcrossScale(self):
        r"""GetNormalizeAcrossScale(RecursiveGaussianImageFilter self) -> bool"""
        return _SimpleITK.RecursiveGaussianImageFilter_GetNormalizeAcrossScale(self)
    ZeroOrder = _SimpleITK.RecursiveGaussianImageFilter_ZeroOrder
    
    FirstOrder = _SimpleITK.RecursiveGaussianImageFilter_FirstOrder
    
    SecondOrder = _SimpleITK.RecursiveGaussianImageFilter_SecondOrder
    

    def SetOrder(self, Order):
        r"""SetOrder(RecursiveGaussianImageFilter self, slicer_itk::simple::RecursiveGaussianImageFilter::OrderType Order)"""
        return _SimpleITK.RecursiveGaussianImageFilter_SetOrder(self, Order)

    def GetOrder(self):
        r"""GetOrder(RecursiveGaussianImageFilter self) -> slicer_itk::simple::RecursiveGaussianImageFilter::OrderType"""
        return _SimpleITK.RecursiveGaussianImageFilter_GetOrder(self)

    def SetDirection(self, Direction):
        r"""SetDirection(RecursiveGaussianImageFilter self, unsigned int Direction)"""
        return _SimpleITK.RecursiveGaussianImageFilter_SetDirection(self, Direction)

    def GetDirection(self):
        r"""GetDirection(RecursiveGaussianImageFilter self) -> unsigned int"""
        return _SimpleITK.RecursiveGaussianImageFilter_GetDirection(self)

    def GetName(self):
        r"""GetName(RecursiveGaussianImageFilter self) -> std::string"""
        return _SimpleITK.RecursiveGaussianImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(RecursiveGaussianImageFilter self) -> std::string"""
        return _SimpleITK.RecursiveGaussianImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(RecursiveGaussianImageFilter self, Image image1) -> Image"""
        return _SimpleITK.RecursiveGaussianImageFilter_Execute(self, image1)

# Register RecursiveGaussianImageFilter in _SimpleITK:
_SimpleITK.RecursiveGaussianImageFilter_swigregister(RecursiveGaussianImageFilter)

def RecursiveGaussian(*args, **kwargs):
    r"""RecursiveGaussian(Image image1, double sigma=1.0, bool normalizeAcrossScale=False, slicer_itk::simple::RecursiveGaussianImageFilter::OrderType order=ZeroOrder, unsigned int direction=0) -> Image"""
    return _SimpleITK.RecursiveGaussian(*args, **kwargs)
class RegionOfInterestImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::RegionOfInterestImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_RegionOfInterestImageFilter

    def __init__(self):
        r"""__init__(RegionOfInterestImageFilter self) -> RegionOfInterestImageFilter"""
        _SimpleITK.RegionOfInterestImageFilter_swiginit(self, _SimpleITK.new_RegionOfInterestImageFilter())

    def SetSize(self, Size):
        r"""SetSize(RegionOfInterestImageFilter self, VectorUInt32 Size)"""
        return _SimpleITK.RegionOfInterestImageFilter_SetSize(self, Size)

    def GetSize(self):
        r"""GetSize(RegionOfInterestImageFilter self) -> VectorUInt32"""
        return _SimpleITK.RegionOfInterestImageFilter_GetSize(self)

    def SetIndex(self, Index):
        r"""SetIndex(RegionOfInterestImageFilter self, VectorInt32 Index)"""
        return _SimpleITK.RegionOfInterestImageFilter_SetIndex(self, Index)

    def GetIndex(self):
        r"""GetIndex(RegionOfInterestImageFilter self) -> VectorInt32"""
        return _SimpleITK.RegionOfInterestImageFilter_GetIndex(self)

    def GetName(self):
        r"""GetName(RegionOfInterestImageFilter self) -> std::string"""
        return _SimpleITK.RegionOfInterestImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(RegionOfInterestImageFilter self) -> std::string"""
        return _SimpleITK.RegionOfInterestImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(RegionOfInterestImageFilter self, Image image1) -> Image"""
        return _SimpleITK.RegionOfInterestImageFilter_Execute(self, image1)

    def SetRegionOfInterest(self, Region):
        r"""SetRegionOfInterest(RegionOfInterestImageFilter self, VectorUInt32 Region)"""
        return _SimpleITK.RegionOfInterestImageFilter_SetRegionOfInterest(self, Region)

# Register RegionOfInterestImageFilter in _SimpleITK:
_SimpleITK.RegionOfInterestImageFilter_swigregister(RegionOfInterestImageFilter)

def RegionOfInterest(*args, **kwargs):
    r"""RegionOfInterest(Image image1, VectorUInt32 size=std::vector< unsigned int >(3, 1), VectorInt32 index=std::vector< int >(3, 0)) -> Image"""
    return _SimpleITK.RegionOfInterest(*args, **kwargs)
class RegionalMaximaImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::RegionalMaximaImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_RegionalMaximaImageFilter

    def __init__(self):
        r"""__init__(RegionalMaximaImageFilter self) -> RegionalMaximaImageFilter"""
        _SimpleITK.RegionalMaximaImageFilter_swiginit(self, _SimpleITK.new_RegionalMaximaImageFilter())

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(RegionalMaximaImageFilter self, double BackgroundValue)"""
        return _SimpleITK.RegionalMaximaImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(RegionalMaximaImageFilter self) -> double"""
        return _SimpleITK.RegionalMaximaImageFilter_GetBackgroundValue(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(RegionalMaximaImageFilter self, double ForegroundValue)"""
        return _SimpleITK.RegionalMaximaImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(RegionalMaximaImageFilter self) -> double"""
        return _SimpleITK.RegionalMaximaImageFilter_GetForegroundValue(self)

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(RegionalMaximaImageFilter self, bool FullyConnected)"""
        return _SimpleITK.RegionalMaximaImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(RegionalMaximaImageFilter self)"""
        return _SimpleITK.RegionalMaximaImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(RegionalMaximaImageFilter self)"""
        return _SimpleITK.RegionalMaximaImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(RegionalMaximaImageFilter self) -> bool"""
        return _SimpleITK.RegionalMaximaImageFilter_GetFullyConnected(self)

    def SetFlatIsMaxima(self, FlatIsMaxima):
        r"""SetFlatIsMaxima(RegionalMaximaImageFilter self, bool FlatIsMaxima)"""
        return _SimpleITK.RegionalMaximaImageFilter_SetFlatIsMaxima(self, FlatIsMaxima)

    def FlatIsMaximaOn(self):
        r"""FlatIsMaximaOn(RegionalMaximaImageFilter self)"""
        return _SimpleITK.RegionalMaximaImageFilter_FlatIsMaximaOn(self)

    def FlatIsMaximaOff(self):
        r"""FlatIsMaximaOff(RegionalMaximaImageFilter self)"""
        return _SimpleITK.RegionalMaximaImageFilter_FlatIsMaximaOff(self)

    def GetFlatIsMaxima(self):
        r"""GetFlatIsMaxima(RegionalMaximaImageFilter self) -> bool"""
        return _SimpleITK.RegionalMaximaImageFilter_GetFlatIsMaxima(self)

    def GetName(self):
        r"""GetName(RegionalMaximaImageFilter self) -> std::string"""
        return _SimpleITK.RegionalMaximaImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(RegionalMaximaImageFilter self) -> std::string"""
        return _SimpleITK.RegionalMaximaImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(RegionalMaximaImageFilter self, Image image1) -> Image"""
        return _SimpleITK.RegionalMaximaImageFilter_Execute(self, image1)

# Register RegionalMaximaImageFilter in _SimpleITK:
_SimpleITK.RegionalMaximaImageFilter_swigregister(RegionalMaximaImageFilter)

def RegionalMaxima(image1, backgroundValue=0.0, foregroundValue=1.0, fullyConnected=False, flatIsMaxima=True):
    r"""RegionalMaxima(Image image1, double backgroundValue=0.0, double foregroundValue=1.0, bool fullyConnected=False, bool flatIsMaxima=True) -> Image"""
    return _SimpleITK.RegionalMaxima(image1, backgroundValue, foregroundValue, fullyConnected, flatIsMaxima)
class RegionalMinimaImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::RegionalMinimaImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_RegionalMinimaImageFilter

    def __init__(self):
        r"""__init__(RegionalMinimaImageFilter self) -> RegionalMinimaImageFilter"""
        _SimpleITK.RegionalMinimaImageFilter_swiginit(self, _SimpleITK.new_RegionalMinimaImageFilter())

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(RegionalMinimaImageFilter self, double BackgroundValue)"""
        return _SimpleITK.RegionalMinimaImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(RegionalMinimaImageFilter self) -> double"""
        return _SimpleITK.RegionalMinimaImageFilter_GetBackgroundValue(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(RegionalMinimaImageFilter self, double ForegroundValue)"""
        return _SimpleITK.RegionalMinimaImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(RegionalMinimaImageFilter self) -> double"""
        return _SimpleITK.RegionalMinimaImageFilter_GetForegroundValue(self)

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(RegionalMinimaImageFilter self, bool FullyConnected)"""
        return _SimpleITK.RegionalMinimaImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(RegionalMinimaImageFilter self)"""
        return _SimpleITK.RegionalMinimaImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(RegionalMinimaImageFilter self)"""
        return _SimpleITK.RegionalMinimaImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(RegionalMinimaImageFilter self) -> bool"""
        return _SimpleITK.RegionalMinimaImageFilter_GetFullyConnected(self)

    def SetFlatIsMinima(self, FlatIsMinima):
        r"""SetFlatIsMinima(RegionalMinimaImageFilter self, bool FlatIsMinima)"""
        return _SimpleITK.RegionalMinimaImageFilter_SetFlatIsMinima(self, FlatIsMinima)

    def FlatIsMinimaOn(self):
        r"""FlatIsMinimaOn(RegionalMinimaImageFilter self)"""
        return _SimpleITK.RegionalMinimaImageFilter_FlatIsMinimaOn(self)

    def FlatIsMinimaOff(self):
        r"""FlatIsMinimaOff(RegionalMinimaImageFilter self)"""
        return _SimpleITK.RegionalMinimaImageFilter_FlatIsMinimaOff(self)

    def GetFlatIsMinima(self):
        r"""GetFlatIsMinima(RegionalMinimaImageFilter self) -> bool"""
        return _SimpleITK.RegionalMinimaImageFilter_GetFlatIsMinima(self)

    def GetName(self):
        r"""GetName(RegionalMinimaImageFilter self) -> std::string"""
        return _SimpleITK.RegionalMinimaImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(RegionalMinimaImageFilter self) -> std::string"""
        return _SimpleITK.RegionalMinimaImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(RegionalMinimaImageFilter self, Image image1) -> Image"""
        return _SimpleITK.RegionalMinimaImageFilter_Execute(self, image1)

# Register RegionalMinimaImageFilter in _SimpleITK:
_SimpleITK.RegionalMinimaImageFilter_swigregister(RegionalMinimaImageFilter)

def RegionalMinima(image1, backgroundValue=0.0, foregroundValue=1.0, fullyConnected=False, flatIsMinima=True):
    r"""RegionalMinima(Image image1, double backgroundValue=0.0, double foregroundValue=1.0, bool fullyConnected=False, bool flatIsMinima=True) -> Image"""
    return _SimpleITK.RegionalMinima(image1, backgroundValue, foregroundValue, fullyConnected, flatIsMinima)
class ReinitializeLevelSetImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ReinitializeLevelSetImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ReinitializeLevelSetImageFilter

    def __init__(self):
        r"""__init__(ReinitializeLevelSetImageFilter self) -> ReinitializeLevelSetImageFilter"""
        _SimpleITK.ReinitializeLevelSetImageFilter_swiginit(self, _SimpleITK.new_ReinitializeLevelSetImageFilter())

    def SetLevelSetValue(self, LevelSetValue):
        r"""SetLevelSetValue(ReinitializeLevelSetImageFilter self, double LevelSetValue)"""
        return _SimpleITK.ReinitializeLevelSetImageFilter_SetLevelSetValue(self, LevelSetValue)

    def GetLevelSetValue(self):
        r"""GetLevelSetValue(ReinitializeLevelSetImageFilter self) -> double"""
        return _SimpleITK.ReinitializeLevelSetImageFilter_GetLevelSetValue(self)

    def SetNarrowBanding(self, NarrowBanding):
        r"""SetNarrowBanding(ReinitializeLevelSetImageFilter self, bool NarrowBanding)"""
        return _SimpleITK.ReinitializeLevelSetImageFilter_SetNarrowBanding(self, NarrowBanding)

    def NarrowBandingOn(self):
        r"""NarrowBandingOn(ReinitializeLevelSetImageFilter self)"""
        return _SimpleITK.ReinitializeLevelSetImageFilter_NarrowBandingOn(self)

    def NarrowBandingOff(self):
        r"""NarrowBandingOff(ReinitializeLevelSetImageFilter self)"""
        return _SimpleITK.ReinitializeLevelSetImageFilter_NarrowBandingOff(self)

    def GetNarrowBanding(self):
        r"""GetNarrowBanding(ReinitializeLevelSetImageFilter self) -> bool"""
        return _SimpleITK.ReinitializeLevelSetImageFilter_GetNarrowBanding(self)

    def SetInputNarrowBandwidth(self, InputNarrowBandwidth):
        r"""SetInputNarrowBandwidth(ReinitializeLevelSetImageFilter self, double InputNarrowBandwidth)"""
        return _SimpleITK.ReinitializeLevelSetImageFilter_SetInputNarrowBandwidth(self, InputNarrowBandwidth)

    def GetInputNarrowBandwidth(self):
        r"""GetInputNarrowBandwidth(ReinitializeLevelSetImageFilter self) -> double"""
        return _SimpleITK.ReinitializeLevelSetImageFilter_GetInputNarrowBandwidth(self)

    def SetOutputNarrowBandwidth(self, OutputNarrowBandwidth):
        r"""SetOutputNarrowBandwidth(ReinitializeLevelSetImageFilter self, double OutputNarrowBandwidth)"""
        return _SimpleITK.ReinitializeLevelSetImageFilter_SetOutputNarrowBandwidth(self, OutputNarrowBandwidth)

    def GetOutputNarrowBandwidth(self):
        r"""GetOutputNarrowBandwidth(ReinitializeLevelSetImageFilter self) -> double"""
        return _SimpleITK.ReinitializeLevelSetImageFilter_GetOutputNarrowBandwidth(self)

    def GetName(self):
        r"""GetName(ReinitializeLevelSetImageFilter self) -> std::string"""
        return _SimpleITK.ReinitializeLevelSetImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ReinitializeLevelSetImageFilter self) -> std::string"""
        return _SimpleITK.ReinitializeLevelSetImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ReinitializeLevelSetImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ReinitializeLevelSetImageFilter_Execute(self, image1)

    def NarrowBandwidth(self, value):
        r"""NarrowBandwidth(ReinitializeLevelSetImageFilter self, double value)"""
        return _SimpleITK.ReinitializeLevelSetImageFilter_NarrowBandwidth(self, value)

# Register ReinitializeLevelSetImageFilter in _SimpleITK:
_SimpleITK.ReinitializeLevelSetImageFilter_swigregister(ReinitializeLevelSetImageFilter)

def ReinitializeLevelSet(image1, levelSetValue=0.0, narrowBanding=False, inputNarrowBandwidth=12.0, outputNarrowBandwidth=12.0):
    r"""ReinitializeLevelSet(Image image1, double levelSetValue=0.0, bool narrowBanding=False, double inputNarrowBandwidth=12.0, double outputNarrowBandwidth=12.0) -> Image"""
    return _SimpleITK.ReinitializeLevelSet(image1, levelSetValue, narrowBanding, inputNarrowBandwidth, outputNarrowBandwidth)
class RelabelComponentImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::RelabelComponentImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_RelabelComponentImageFilter

    def __init__(self):
        r"""__init__(RelabelComponentImageFilter self) -> RelabelComponentImageFilter"""
        _SimpleITK.RelabelComponentImageFilter_swiginit(self, _SimpleITK.new_RelabelComponentImageFilter())

    def SetMinimumObjectSize(self, MinimumObjectSize):
        r"""SetMinimumObjectSize(RelabelComponentImageFilter self, uint64_t MinimumObjectSize)"""
        return _SimpleITK.RelabelComponentImageFilter_SetMinimumObjectSize(self, MinimumObjectSize)

    def GetMinimumObjectSize(self):
        r"""GetMinimumObjectSize(RelabelComponentImageFilter self) -> uint64_t"""
        return _SimpleITK.RelabelComponentImageFilter_GetMinimumObjectSize(self)

    def SetSortByObjectSize(self, SortByObjectSize):
        r"""SetSortByObjectSize(RelabelComponentImageFilter self, bool SortByObjectSize)"""
        return _SimpleITK.RelabelComponentImageFilter_SetSortByObjectSize(self, SortByObjectSize)

    def SortByObjectSizeOn(self):
        r"""SortByObjectSizeOn(RelabelComponentImageFilter self)"""
        return _SimpleITK.RelabelComponentImageFilter_SortByObjectSizeOn(self)

    def SortByObjectSizeOff(self):
        r"""SortByObjectSizeOff(RelabelComponentImageFilter self)"""
        return _SimpleITK.RelabelComponentImageFilter_SortByObjectSizeOff(self)

    def GetSortByObjectSize(self):
        r"""GetSortByObjectSize(RelabelComponentImageFilter self) -> bool"""
        return _SimpleITK.RelabelComponentImageFilter_GetSortByObjectSize(self)

    def GetNumberOfObjects(self):
        r"""GetNumberOfObjects(RelabelComponentImageFilter self) -> uint32_t"""
        return _SimpleITK.RelabelComponentImageFilter_GetNumberOfObjects(self)

    def GetOriginalNumberOfObjects(self):
        r"""GetOriginalNumberOfObjects(RelabelComponentImageFilter self) -> uint32_t"""
        return _SimpleITK.RelabelComponentImageFilter_GetOriginalNumberOfObjects(self)

    def GetSizeOfObjectsInPhysicalUnits(self):
        r"""GetSizeOfObjectsInPhysicalUnits(RelabelComponentImageFilter self) -> VectorFloat"""
        return _SimpleITK.RelabelComponentImageFilter_GetSizeOfObjectsInPhysicalUnits(self)

    def GetSizeOfObjectsInPixels(self):
        r"""GetSizeOfObjectsInPixels(RelabelComponentImageFilter self) -> VectorUInt64"""
        return _SimpleITK.RelabelComponentImageFilter_GetSizeOfObjectsInPixels(self)

    def GetName(self):
        r"""GetName(RelabelComponentImageFilter self) -> std::string"""
        return _SimpleITK.RelabelComponentImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(RelabelComponentImageFilter self) -> std::string"""
        return _SimpleITK.RelabelComponentImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(RelabelComponentImageFilter self, Image image1) -> Image"""
        return _SimpleITK.RelabelComponentImageFilter_Execute(self, image1)

# Register RelabelComponentImageFilter in _SimpleITK:
_SimpleITK.RelabelComponentImageFilter_swigregister(RelabelComponentImageFilter)

def RelabelComponent(image1, minimumObjectSize=0, sortByObjectSize=True):
    r"""RelabelComponent(Image image1, uint64_t minimumObjectSize=0, bool sortByObjectSize=True) -> Image"""
    return _SimpleITK.RelabelComponent(image1, minimumObjectSize, sortByObjectSize)
class RelabelLabelMapFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::RelabelLabelMapFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_RelabelLabelMapFilter

    def __init__(self):
        r"""__init__(RelabelLabelMapFilter self) -> RelabelLabelMapFilter"""
        _SimpleITK.RelabelLabelMapFilter_swiginit(self, _SimpleITK.new_RelabelLabelMapFilter())

    def SetReverseOrdering(self, ReverseOrdering):
        r"""SetReverseOrdering(RelabelLabelMapFilter self, bool ReverseOrdering)"""
        return _SimpleITK.RelabelLabelMapFilter_SetReverseOrdering(self, ReverseOrdering)

    def ReverseOrderingOn(self):
        r"""ReverseOrderingOn(RelabelLabelMapFilter self)"""
        return _SimpleITK.RelabelLabelMapFilter_ReverseOrderingOn(self)

    def ReverseOrderingOff(self):
        r"""ReverseOrderingOff(RelabelLabelMapFilter self)"""
        return _SimpleITK.RelabelLabelMapFilter_ReverseOrderingOff(self)

    def GetReverseOrdering(self):
        r"""GetReverseOrdering(RelabelLabelMapFilter self) -> bool"""
        return _SimpleITK.RelabelLabelMapFilter_GetReverseOrdering(self)

    def GetName(self):
        r"""GetName(RelabelLabelMapFilter self) -> std::string"""
        return _SimpleITK.RelabelLabelMapFilter_GetName(self)

    def __str__(self):
        r"""__str__(RelabelLabelMapFilter self) -> std::string"""
        return _SimpleITK.RelabelLabelMapFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(RelabelLabelMapFilter self, Image image1) -> Image"""
        return _SimpleITK.RelabelLabelMapFilter_Execute(self, image1)

# Register RelabelLabelMapFilter in _SimpleITK:
_SimpleITK.RelabelLabelMapFilter_swigregister(RelabelLabelMapFilter)

def RelabelLabelMap(image1, reverseOrdering=True):
    r"""RelabelLabelMap(Image image1, bool reverseOrdering=True) -> Image"""
    return _SimpleITK.RelabelLabelMap(image1, reverseOrdering)
class RenyiEntropyThresholdImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::RenyiEntropyThresholdImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_RenyiEntropyThresholdImageFilter

    def __init__(self):
        r"""__init__(RenyiEntropyThresholdImageFilter self) -> RenyiEntropyThresholdImageFilter"""
        _SimpleITK.RenyiEntropyThresholdImageFilter_swiginit(self, _SimpleITK.new_RenyiEntropyThresholdImageFilter())

    def SetInsideValue(self, InsideValue):
        r"""SetInsideValue(RenyiEntropyThresholdImageFilter self, uint8_t InsideValue)"""
        return _SimpleITK.RenyiEntropyThresholdImageFilter_SetInsideValue(self, InsideValue)

    def GetInsideValue(self):
        r"""GetInsideValue(RenyiEntropyThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.RenyiEntropyThresholdImageFilter_GetInsideValue(self)

    def SetOutsideValue(self, OutsideValue):
        r"""SetOutsideValue(RenyiEntropyThresholdImageFilter self, uint8_t OutsideValue)"""
        return _SimpleITK.RenyiEntropyThresholdImageFilter_SetOutsideValue(self, OutsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(RenyiEntropyThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.RenyiEntropyThresholdImageFilter_GetOutsideValue(self)

    def SetNumberOfHistogramBins(self, NumberOfHistogramBins):
        r"""SetNumberOfHistogramBins(RenyiEntropyThresholdImageFilter self, uint32_t NumberOfHistogramBins)"""
        return _SimpleITK.RenyiEntropyThresholdImageFilter_SetNumberOfHistogramBins(self, NumberOfHistogramBins)

    def GetNumberOfHistogramBins(self):
        r"""GetNumberOfHistogramBins(RenyiEntropyThresholdImageFilter self) -> uint32_t"""
        return _SimpleITK.RenyiEntropyThresholdImageFilter_GetNumberOfHistogramBins(self)

    def SetMaskOutput(self, MaskOutput):
        r"""SetMaskOutput(RenyiEntropyThresholdImageFilter self, bool MaskOutput)"""
        return _SimpleITK.RenyiEntropyThresholdImageFilter_SetMaskOutput(self, MaskOutput)

    def MaskOutputOn(self):
        r"""MaskOutputOn(RenyiEntropyThresholdImageFilter self)"""
        return _SimpleITK.RenyiEntropyThresholdImageFilter_MaskOutputOn(self)

    def MaskOutputOff(self):
        r"""MaskOutputOff(RenyiEntropyThresholdImageFilter self)"""
        return _SimpleITK.RenyiEntropyThresholdImageFilter_MaskOutputOff(self)

    def GetMaskOutput(self):
        r"""GetMaskOutput(RenyiEntropyThresholdImageFilter self) -> bool"""
        return _SimpleITK.RenyiEntropyThresholdImageFilter_GetMaskOutput(self)

    def SetMaskValue(self, MaskValue):
        r"""SetMaskValue(RenyiEntropyThresholdImageFilter self, uint8_t MaskValue)"""
        return _SimpleITK.RenyiEntropyThresholdImageFilter_SetMaskValue(self, MaskValue)

    def GetMaskValue(self):
        r"""GetMaskValue(RenyiEntropyThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.RenyiEntropyThresholdImageFilter_GetMaskValue(self)

    def GetThreshold(self):
        r"""GetThreshold(RenyiEntropyThresholdImageFilter self) -> double"""
        return _SimpleITK.RenyiEntropyThresholdImageFilter_GetThreshold(self)

    def GetName(self):
        r"""GetName(RenyiEntropyThresholdImageFilter self) -> std::string"""
        return _SimpleITK.RenyiEntropyThresholdImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(RenyiEntropyThresholdImageFilter self) -> std::string"""
        return _SimpleITK.RenyiEntropyThresholdImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(RenyiEntropyThresholdImageFilter self, Image image, Image maskImage) -> Image
        Execute(RenyiEntropyThresholdImageFilter self, Image image) -> Image
        """
        return _SimpleITK.RenyiEntropyThresholdImageFilter_Execute(self, *args)

# Register RenyiEntropyThresholdImageFilter in _SimpleITK:
_SimpleITK.RenyiEntropyThresholdImageFilter_swigregister(RenyiEntropyThresholdImageFilter)

def RenyiEntropyThreshold(*args):
    r"""
    RenyiEntropyThreshold(Image image, Image maskImage, uint8_t insideValue=1, uint8_t outsideValue=0, uint32_t numberOfHistogramBins=256, bool maskOutput=True, uint8_t maskValue=255) -> Image
    RenyiEntropyThreshold(Image image, uint8_t insideValue=1, uint8_t outsideValue=0, uint32_t numberOfHistogramBins=256, bool maskOutput=True, uint8_t maskValue=255) -> Image
    """
    return _SimpleITK.RenyiEntropyThreshold(*args)
class ResampleImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ResampleImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ResampleImageFilter

    def __init__(self):
        r"""__init__(ResampleImageFilter self) -> ResampleImageFilter"""
        _SimpleITK.ResampleImageFilter_swiginit(self, _SimpleITK.new_ResampleImageFilter())

    def SetSize(self, Size):
        r"""SetSize(ResampleImageFilter self, VectorUInt32 Size)"""
        return _SimpleITK.ResampleImageFilter_SetSize(self, Size)

    def GetSize(self):
        r"""GetSize(ResampleImageFilter self) -> VectorUInt32"""
        return _SimpleITK.ResampleImageFilter_GetSize(self)

    def SetTransform(self, Transform):
        r"""SetTransform(ResampleImageFilter self, Transform Transform)"""
        return _SimpleITK.ResampleImageFilter_SetTransform(self, Transform)

    def GetTransform(self):
        r"""GetTransform(ResampleImageFilter self) -> Transform"""
        return _SimpleITK.ResampleImageFilter_GetTransform(self)

    def SetInterpolator(self, Interpolator):
        r"""SetInterpolator(ResampleImageFilter self, slicer_itk::simple::InterpolatorEnum Interpolator)"""
        return _SimpleITK.ResampleImageFilter_SetInterpolator(self, Interpolator)

    def GetInterpolator(self):
        r"""GetInterpolator(ResampleImageFilter self) -> slicer_itk::simple::InterpolatorEnum"""
        return _SimpleITK.ResampleImageFilter_GetInterpolator(self)

    def SetOutputOrigin(self, OutputOrigin):
        r"""SetOutputOrigin(ResampleImageFilter self, VectorDouble OutputOrigin)"""
        return _SimpleITK.ResampleImageFilter_SetOutputOrigin(self, OutputOrigin)

    def GetOutputOrigin(self):
        r"""GetOutputOrigin(ResampleImageFilter self) -> VectorDouble"""
        return _SimpleITK.ResampleImageFilter_GetOutputOrigin(self)

    def SetOutputSpacing(self, OutputSpacing):
        r"""SetOutputSpacing(ResampleImageFilter self, VectorDouble OutputSpacing)"""
        return _SimpleITK.ResampleImageFilter_SetOutputSpacing(self, OutputSpacing)

    def GetOutputSpacing(self):
        r"""GetOutputSpacing(ResampleImageFilter self) -> VectorDouble"""
        return _SimpleITK.ResampleImageFilter_GetOutputSpacing(self)

    def SetOutputDirection(self, OutputDirection):
        r"""SetOutputDirection(ResampleImageFilter self, VectorDouble OutputDirection)"""
        return _SimpleITK.ResampleImageFilter_SetOutputDirection(self, OutputDirection)

    def GetOutputDirection(self):
        r"""GetOutputDirection(ResampleImageFilter self) -> VectorDouble"""
        return _SimpleITK.ResampleImageFilter_GetOutputDirection(self)

    def SetDefaultPixelValue(self, DefaultPixelValue):
        r"""SetDefaultPixelValue(ResampleImageFilter self, double DefaultPixelValue)"""
        return _SimpleITK.ResampleImageFilter_SetDefaultPixelValue(self, DefaultPixelValue)

    def GetDefaultPixelValue(self):
        r"""GetDefaultPixelValue(ResampleImageFilter self) -> double"""
        return _SimpleITK.ResampleImageFilter_GetDefaultPixelValue(self)

    def SetOutputPixelType(self, OutputPixelType):
        r"""SetOutputPixelType(ResampleImageFilter self, slicer_itk::simple::PixelIDValueEnum OutputPixelType)"""
        return _SimpleITK.ResampleImageFilter_SetOutputPixelType(self, OutputPixelType)

    def GetOutputPixelType(self):
        r"""GetOutputPixelType(ResampleImageFilter self) -> slicer_itk::simple::PixelIDValueEnum"""
        return _SimpleITK.ResampleImageFilter_GetOutputPixelType(self)

    def SetUseNearestNeighborExtrapolator(self, UseNearestNeighborExtrapolator):
        r"""SetUseNearestNeighborExtrapolator(ResampleImageFilter self, bool UseNearestNeighborExtrapolator)"""
        return _SimpleITK.ResampleImageFilter_SetUseNearestNeighborExtrapolator(self, UseNearestNeighborExtrapolator)

    def UseNearestNeighborExtrapolatorOn(self):
        r"""UseNearestNeighborExtrapolatorOn(ResampleImageFilter self)"""
        return _SimpleITK.ResampleImageFilter_UseNearestNeighborExtrapolatorOn(self)

    def UseNearestNeighborExtrapolatorOff(self):
        r"""UseNearestNeighborExtrapolatorOff(ResampleImageFilter self)"""
        return _SimpleITK.ResampleImageFilter_UseNearestNeighborExtrapolatorOff(self)

    def GetUseNearestNeighborExtrapolator(self):
        r"""GetUseNearestNeighborExtrapolator(ResampleImageFilter self) -> bool"""
        return _SimpleITK.ResampleImageFilter_GetUseNearestNeighborExtrapolator(self)

    def GetName(self):
        r"""GetName(ResampleImageFilter self) -> std::string"""
        return _SimpleITK.ResampleImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ResampleImageFilter self) -> std::string"""
        return _SimpleITK.ResampleImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ResampleImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ResampleImageFilter_Execute(self, image1)

    def SetReferenceImage(self, refImage):
        r"""SetReferenceImage(ResampleImageFilter self, Image refImage)"""
        return _SimpleITK.ResampleImageFilter_SetReferenceImage(self, refImage)

# Register ResampleImageFilter in _SimpleITK:
_SimpleITK.ResampleImageFilter_swigregister(ResampleImageFilter)
class RescaleIntensityImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::RescaleIntensityImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_RescaleIntensityImageFilter

    def __init__(self):
        r"""__init__(RescaleIntensityImageFilter self) -> RescaleIntensityImageFilter"""
        _SimpleITK.RescaleIntensityImageFilter_swiginit(self, _SimpleITK.new_RescaleIntensityImageFilter())

    def SetOutputMinimum(self, OutputMinimum):
        r"""SetOutputMinimum(RescaleIntensityImageFilter self, double OutputMinimum)"""
        return _SimpleITK.RescaleIntensityImageFilter_SetOutputMinimum(self, OutputMinimum)

    def GetOutputMinimum(self):
        r"""GetOutputMinimum(RescaleIntensityImageFilter self) -> double"""
        return _SimpleITK.RescaleIntensityImageFilter_GetOutputMinimum(self)

    def SetOutputMaximum(self, OutputMaximum):
        r"""SetOutputMaximum(RescaleIntensityImageFilter self, double OutputMaximum)"""
        return _SimpleITK.RescaleIntensityImageFilter_SetOutputMaximum(self, OutputMaximum)

    def GetOutputMaximum(self):
        r"""GetOutputMaximum(RescaleIntensityImageFilter self) -> double"""
        return _SimpleITK.RescaleIntensityImageFilter_GetOutputMaximum(self)

    def GetName(self):
        r"""GetName(RescaleIntensityImageFilter self) -> std::string"""
        return _SimpleITK.RescaleIntensityImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(RescaleIntensityImageFilter self) -> std::string"""
        return _SimpleITK.RescaleIntensityImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(RescaleIntensityImageFilter self, Image image1) -> Image"""
        return _SimpleITK.RescaleIntensityImageFilter_Execute(self, image1)

# Register RescaleIntensityImageFilter in _SimpleITK:
_SimpleITK.RescaleIntensityImageFilter_swigregister(RescaleIntensityImageFilter)

def RescaleIntensity(image1, outputMinimum=0, outputMaximum=255):
    r"""RescaleIntensity(Image image1, double outputMinimum=0, double outputMaximum=255) -> Image"""
    return _SimpleITK.RescaleIntensity(image1, outputMinimum, outputMaximum)
class RichardsonLucyDeconvolutionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::RichardsonLucyDeconvolutionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_RichardsonLucyDeconvolutionImageFilter

    def __init__(self):
        r"""__init__(RichardsonLucyDeconvolutionImageFilter self) -> RichardsonLucyDeconvolutionImageFilter"""
        _SimpleITK.RichardsonLucyDeconvolutionImageFilter_swiginit(self, _SimpleITK.new_RichardsonLucyDeconvolutionImageFilter())

    def SetNumberOfIterations(self, NumberOfIterations):
        r"""SetNumberOfIterations(RichardsonLucyDeconvolutionImageFilter self, int NumberOfIterations)"""
        return _SimpleITK.RichardsonLucyDeconvolutionImageFilter_SetNumberOfIterations(self, NumberOfIterations)

    def GetNumberOfIterations(self):
        r"""GetNumberOfIterations(RichardsonLucyDeconvolutionImageFilter self) -> int"""
        return _SimpleITK.RichardsonLucyDeconvolutionImageFilter_GetNumberOfIterations(self)

    def SetNormalize(self, Normalize):
        r"""SetNormalize(RichardsonLucyDeconvolutionImageFilter self, bool Normalize)"""
        return _SimpleITK.RichardsonLucyDeconvolutionImageFilter_SetNormalize(self, Normalize)

    def NormalizeOn(self):
        r"""NormalizeOn(RichardsonLucyDeconvolutionImageFilter self)"""
        return _SimpleITK.RichardsonLucyDeconvolutionImageFilter_NormalizeOn(self)

    def NormalizeOff(self):
        r"""NormalizeOff(RichardsonLucyDeconvolutionImageFilter self)"""
        return _SimpleITK.RichardsonLucyDeconvolutionImageFilter_NormalizeOff(self)

    def GetNormalize(self):
        r"""GetNormalize(RichardsonLucyDeconvolutionImageFilter self) -> bool"""
        return _SimpleITK.RichardsonLucyDeconvolutionImageFilter_GetNormalize(self)
    ZERO_PAD = _SimpleITK.RichardsonLucyDeconvolutionImageFilter_ZERO_PAD
    
    ZERO_FLUX_NEUMANN_PAD = _SimpleITK.RichardsonLucyDeconvolutionImageFilter_ZERO_FLUX_NEUMANN_PAD
    
    PERIODIC_PAD = _SimpleITK.RichardsonLucyDeconvolutionImageFilter_PERIODIC_PAD
    

    def SetBoundaryCondition(self, BoundaryCondition):
        r"""SetBoundaryCondition(RichardsonLucyDeconvolutionImageFilter self, slicer_itk::simple::RichardsonLucyDeconvolutionImageFilter::BoundaryConditionType BoundaryCondition)"""
        return _SimpleITK.RichardsonLucyDeconvolutionImageFilter_SetBoundaryCondition(self, BoundaryCondition)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(RichardsonLucyDeconvolutionImageFilter self) -> slicer_itk::simple::RichardsonLucyDeconvolutionImageFilter::BoundaryConditionType"""
        return _SimpleITK.RichardsonLucyDeconvolutionImageFilter_GetBoundaryCondition(self)
    SAME = _SimpleITK.RichardsonLucyDeconvolutionImageFilter_SAME
    
    VALID = _SimpleITK.RichardsonLucyDeconvolutionImageFilter_VALID
    

    def SetOutputRegionMode(self, OutputRegionMode):
        r"""SetOutputRegionMode(RichardsonLucyDeconvolutionImageFilter self, slicer_itk::simple::RichardsonLucyDeconvolutionImageFilter::OutputRegionModeType OutputRegionMode)"""
        return _SimpleITK.RichardsonLucyDeconvolutionImageFilter_SetOutputRegionMode(self, OutputRegionMode)

    def GetOutputRegionMode(self):
        r"""GetOutputRegionMode(RichardsonLucyDeconvolutionImageFilter self) -> slicer_itk::simple::RichardsonLucyDeconvolutionImageFilter::OutputRegionModeType"""
        return _SimpleITK.RichardsonLucyDeconvolutionImageFilter_GetOutputRegionMode(self)

    def GetName(self):
        r"""GetName(RichardsonLucyDeconvolutionImageFilter self) -> std::string"""
        return _SimpleITK.RichardsonLucyDeconvolutionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(RichardsonLucyDeconvolutionImageFilter self) -> std::string"""
        return _SimpleITK.RichardsonLucyDeconvolutionImageFilter___str__(self)

    def Execute(self, image1, image2):
        r"""Execute(RichardsonLucyDeconvolutionImageFilter self, Image image1, Image image2) -> Image"""
        return _SimpleITK.RichardsonLucyDeconvolutionImageFilter_Execute(self, image1, image2)

# Register RichardsonLucyDeconvolutionImageFilter in _SimpleITK:
_SimpleITK.RichardsonLucyDeconvolutionImageFilter_swigregister(RichardsonLucyDeconvolutionImageFilter)

def RichardsonLucyDeconvolution(*args, **kwargs):
    r"""RichardsonLucyDeconvolution(Image image1, Image image2, int numberOfIterations=1, bool normalize=False, slicer_itk::simple::RichardsonLucyDeconvolutionImageFilter::BoundaryConditionType boundaryCondition=ZERO_FLUX_NEUMANN_PAD, slicer_itk::simple::RichardsonLucyDeconvolutionImageFilter::OutputRegionModeType outputRegionMode=SAME) -> Image"""
    return _SimpleITK.RichardsonLucyDeconvolution(*args, **kwargs)
class RoundImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::RoundImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_RoundImageFilter

    def __init__(self):
        r"""__init__(RoundImageFilter self) -> RoundImageFilter"""
        _SimpleITK.RoundImageFilter_swiginit(self, _SimpleITK.new_RoundImageFilter())

    def GetName(self):
        r"""GetName(RoundImageFilter self) -> std::string"""
        return _SimpleITK.RoundImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(RoundImageFilter self) -> std::string"""
        return _SimpleITK.RoundImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(RoundImageFilter self, Image image1) -> Image"""
        return _SimpleITK.RoundImageFilter_Execute(self, image1)

# Register RoundImageFilter in _SimpleITK:
_SimpleITK.RoundImageFilter_swigregister(RoundImageFilter)

def Round(image1):
    r"""Round(Image image1) -> Image"""
    return _SimpleITK.Round(image1)
class SLICImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::SLICImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_SLICImageFilter

    def __init__(self):
        r"""__init__(SLICImageFilter self) -> SLICImageFilter"""
        _SimpleITK.SLICImageFilter_swiginit(self, _SimpleITK.new_SLICImageFilter())

    def SetSuperGridSize(self, SuperGridSize):
        r"""SetSuperGridSize(SLICImageFilter self, VectorUInt32 SuperGridSize)"""
        return _SimpleITK.SLICImageFilter_SetSuperGridSize(self, SuperGridSize)

    def GetSuperGridSize(self):
        r"""GetSuperGridSize(SLICImageFilter self) -> VectorUInt32"""
        return _SimpleITK.SLICImageFilter_GetSuperGridSize(self)

    def SetSpatialProximityWeight(self, SpatialProximityWeight):
        r"""SetSpatialProximityWeight(SLICImageFilter self, double SpatialProximityWeight)"""
        return _SimpleITK.SLICImageFilter_SetSpatialProximityWeight(self, SpatialProximityWeight)

    def GetSpatialProximityWeight(self):
        r"""GetSpatialProximityWeight(SLICImageFilter self) -> double"""
        return _SimpleITK.SLICImageFilter_GetSpatialProximityWeight(self)

    def SetMaximumNumberOfIterations(self, MaximumNumberOfIterations):
        r"""SetMaximumNumberOfIterations(SLICImageFilter self, uint32_t MaximumNumberOfIterations)"""
        return _SimpleITK.SLICImageFilter_SetMaximumNumberOfIterations(self, MaximumNumberOfIterations)

    def GetMaximumNumberOfIterations(self):
        r"""GetMaximumNumberOfIterations(SLICImageFilter self) -> uint32_t"""
        return _SimpleITK.SLICImageFilter_GetMaximumNumberOfIterations(self)

    def SetEnforceConnectivity(self, EnforceConnectivity):
        r"""SetEnforceConnectivity(SLICImageFilter self, bool EnforceConnectivity)"""
        return _SimpleITK.SLICImageFilter_SetEnforceConnectivity(self, EnforceConnectivity)

    def EnforceConnectivityOn(self):
        r"""EnforceConnectivityOn(SLICImageFilter self)"""
        return _SimpleITK.SLICImageFilter_EnforceConnectivityOn(self)

    def EnforceConnectivityOff(self):
        r"""EnforceConnectivityOff(SLICImageFilter self)"""
        return _SimpleITK.SLICImageFilter_EnforceConnectivityOff(self)

    def GetEnforceConnectivity(self):
        r"""GetEnforceConnectivity(SLICImageFilter self) -> bool"""
        return _SimpleITK.SLICImageFilter_GetEnforceConnectivity(self)

    def SetInitializationPerturbation(self, InitializationPerturbation):
        r"""SetInitializationPerturbation(SLICImageFilter self, bool InitializationPerturbation)"""
        return _SimpleITK.SLICImageFilter_SetInitializationPerturbation(self, InitializationPerturbation)

    def InitializationPerturbationOn(self):
        r"""InitializationPerturbationOn(SLICImageFilter self)"""
        return _SimpleITK.SLICImageFilter_InitializationPerturbationOn(self)

    def InitializationPerturbationOff(self):
        r"""InitializationPerturbationOff(SLICImageFilter self)"""
        return _SimpleITK.SLICImageFilter_InitializationPerturbationOff(self)

    def GetInitializationPerturbation(self):
        r"""GetInitializationPerturbation(SLICImageFilter self) -> bool"""
        return _SimpleITK.SLICImageFilter_GetInitializationPerturbation(self)

    def GetAverageResidual(self):
        r"""GetAverageResidual(SLICImageFilter self) -> double"""
        return _SimpleITK.SLICImageFilter_GetAverageResidual(self)

    def GetName(self):
        r"""GetName(SLICImageFilter self) -> std::string"""
        return _SimpleITK.SLICImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(SLICImageFilter self) -> std::string"""
        return _SimpleITK.SLICImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(SLICImageFilter self, Image image1) -> Image"""
        return _SimpleITK.SLICImageFilter_Execute(self, image1)

# Register SLICImageFilter in _SimpleITK:
_SimpleITK.SLICImageFilter_swigregister(SLICImageFilter)

def SLIC(*args, **kwargs):
    r"""SLIC(Image image1, VectorUInt32 superGridSize=std::vector< unsigned int >(3, 50), double spatialProximityWeight=10.0, uint32_t maximumNumberOfIterations=5, bool enforceConnectivity=True, bool initializationPerturbation=True) -> Image"""
    return _SimpleITK.SLIC(*args, **kwargs)
class STAPLEImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::STAPLEImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_STAPLEImageFilter

    def __init__(self):
        r"""__init__(STAPLEImageFilter self) -> STAPLEImageFilter"""
        _SimpleITK.STAPLEImageFilter_swiginit(self, _SimpleITK.new_STAPLEImageFilter())

    def SetConfidenceWeight(self, ConfidenceWeight):
        r"""SetConfidenceWeight(STAPLEImageFilter self, double ConfidenceWeight)"""
        return _SimpleITK.STAPLEImageFilter_SetConfidenceWeight(self, ConfidenceWeight)

    def GetConfidenceWeight(self):
        r"""GetConfidenceWeight(STAPLEImageFilter self) -> double"""
        return _SimpleITK.STAPLEImageFilter_GetConfidenceWeight(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(STAPLEImageFilter self, double ForegroundValue)"""
        return _SimpleITK.STAPLEImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(STAPLEImageFilter self) -> double"""
        return _SimpleITK.STAPLEImageFilter_GetForegroundValue(self)

    def SetMaximumIterations(self, MaximumIterations):
        r"""SetMaximumIterations(STAPLEImageFilter self, unsigned int MaximumIterations)"""
        return _SimpleITK.STAPLEImageFilter_SetMaximumIterations(self, MaximumIterations)

    def GetMaximumIterations(self):
        r"""GetMaximumIterations(STAPLEImageFilter self) -> unsigned int"""
        return _SimpleITK.STAPLEImageFilter_GetMaximumIterations(self)

    def GetElapsedIterations(self):
        r"""GetElapsedIterations(STAPLEImageFilter self) -> uint32_t"""
        return _SimpleITK.STAPLEImageFilter_GetElapsedIterations(self)

    def GetSensitivity(self):
        r"""GetSensitivity(STAPLEImageFilter self) -> VectorDouble"""
        return _SimpleITK.STAPLEImageFilter_GetSensitivity(self)

    def GetSpecificity(self):
        r"""GetSpecificity(STAPLEImageFilter self) -> VectorDouble"""
        return _SimpleITK.STAPLEImageFilter_GetSpecificity(self)

    def GetName(self):
        r"""GetName(STAPLEImageFilter self) -> std::string"""
        return _SimpleITK.STAPLEImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(STAPLEImageFilter self) -> std::string"""
        return _SimpleITK.STAPLEImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(STAPLEImageFilter self, VectorOfImage images) -> Image
        Execute(STAPLEImageFilter self, Image image1) -> Image
        Execute(STAPLEImageFilter self, Image image1, Image image2) -> Image
        Execute(STAPLEImageFilter self, Image image1, Image image2, Image image3) -> Image
        Execute(STAPLEImageFilter self, Image image1, Image image2, Image image3, Image image4) -> Image
        Execute(STAPLEImageFilter self, Image image1, Image image2, Image image3, Image image4, Image image5) -> Image
        """
        return _SimpleITK.STAPLEImageFilter_Execute(self, *args)

# Register STAPLEImageFilter in _SimpleITK:
_SimpleITK.STAPLEImageFilter_swigregister(STAPLEImageFilter)

def STAPLE(*args):
    r"""
    STAPLE(VectorOfImage images, double confidenceWeight=1.0, double foregroundValue=1.0, unsigned int maximumIterations=std::numeric_limits< unsigned int >::max()) -> Image
    STAPLE(Image image1, double confidenceWeight=1.0, double foregroundValue=1.0, unsigned int maximumIterations=std::numeric_limits< unsigned int >::max()) -> Image
    STAPLE(Image image1, Image image2, double confidenceWeight=1.0, double foregroundValue=1.0, unsigned int maximumIterations=std::numeric_limits< unsigned int >::max()) -> Image
    STAPLE(Image image1, Image image2, Image image3, double confidenceWeight=1.0, double foregroundValue=1.0, unsigned int maximumIterations=std::numeric_limits< unsigned int >::max()) -> Image
    STAPLE(Image image1, Image image2, Image image3, Image image4, double confidenceWeight=1.0, double foregroundValue=1.0, unsigned int maximumIterations=std::numeric_limits< unsigned int >::max()) -> Image
    STAPLE(Image image1, Image image2, Image image3, Image image4, Image image5, double confidenceWeight=1.0, double foregroundValue=1.0, unsigned int maximumIterations=std::numeric_limits< unsigned int >::max()) -> Image
    """
    return _SimpleITK.STAPLE(*args)
class SaltAndPepperNoiseImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::SaltAndPepperNoiseImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_SaltAndPepperNoiseImageFilter

    def __init__(self):
        r"""__init__(SaltAndPepperNoiseImageFilter self) -> SaltAndPepperNoiseImageFilter"""
        _SimpleITK.SaltAndPepperNoiseImageFilter_swiginit(self, _SimpleITK.new_SaltAndPepperNoiseImageFilter())

    def SetProbability(self, Probability):
        r"""SetProbability(SaltAndPepperNoiseImageFilter self, double Probability)"""
        return _SimpleITK.SaltAndPepperNoiseImageFilter_SetProbability(self, Probability)

    def GetProbability(self):
        r"""GetProbability(SaltAndPepperNoiseImageFilter self) -> double"""
        return _SimpleITK.SaltAndPepperNoiseImageFilter_GetProbability(self)

    def SetSeed(self, Seed):
        r"""SetSeed(SaltAndPepperNoiseImageFilter self, uint32_t Seed)"""
        return _SimpleITK.SaltAndPepperNoiseImageFilter_SetSeed(self, Seed)

    def GetSeed(self):
        r"""GetSeed(SaltAndPepperNoiseImageFilter self) -> uint32_t"""
        return _SimpleITK.SaltAndPepperNoiseImageFilter_GetSeed(self)

    def GetName(self):
        r"""GetName(SaltAndPepperNoiseImageFilter self) -> std::string"""
        return _SimpleITK.SaltAndPepperNoiseImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(SaltAndPepperNoiseImageFilter self) -> std::string"""
        return _SimpleITK.SaltAndPepperNoiseImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(SaltAndPepperNoiseImageFilter self, Image image1) -> Image"""
        return _SimpleITK.SaltAndPepperNoiseImageFilter_Execute(self, image1)

# Register SaltAndPepperNoiseImageFilter in _SimpleITK:
_SimpleITK.SaltAndPepperNoiseImageFilter_swigregister(SaltAndPepperNoiseImageFilter)

def SaltAndPepperNoise(*args, **kwargs):
    r"""SaltAndPepperNoise(Image image1, double probability=0.01, uint32_t seed=(uint32_t) slicer_itk::simple::sitkWallClock) -> Image"""
    return _SimpleITK.SaltAndPepperNoise(*args, **kwargs)
class ScalarChanAndVeseDenseLevelSetImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ScalarChanAndVeseDenseLevelSetImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ScalarChanAndVeseDenseLevelSetImageFilter

    def __init__(self):
        r"""__init__(ScalarChanAndVeseDenseLevelSetImageFilter self) -> ScalarChanAndVeseDenseLevelSetImageFilter"""
        _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_swiginit(self, _SimpleITK.new_ScalarChanAndVeseDenseLevelSetImageFilter())

    def SetMaximumRMSError(self, MaximumRMSError):
        r"""SetMaximumRMSError(ScalarChanAndVeseDenseLevelSetImageFilter self, double MaximumRMSError)"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_SetMaximumRMSError(self, MaximumRMSError)

    def GetMaximumRMSError(self):
        r"""GetMaximumRMSError(ScalarChanAndVeseDenseLevelSetImageFilter self) -> double"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_GetMaximumRMSError(self)

    def SetNumberOfIterations(self, NumberOfIterations):
        r"""SetNumberOfIterations(ScalarChanAndVeseDenseLevelSetImageFilter self, uint32_t NumberOfIterations)"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_SetNumberOfIterations(self, NumberOfIterations)

    def GetNumberOfIterations(self):
        r"""GetNumberOfIterations(ScalarChanAndVeseDenseLevelSetImageFilter self) -> uint32_t"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_GetNumberOfIterations(self)

    def SetLambda1(self, Lambda1):
        r"""SetLambda1(ScalarChanAndVeseDenseLevelSetImageFilter self, double Lambda1)"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_SetLambda1(self, Lambda1)

    def GetLambda1(self):
        r"""GetLambda1(ScalarChanAndVeseDenseLevelSetImageFilter self) -> double"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_GetLambda1(self)

    def SetLambda2(self, Lambda2):
        r"""SetLambda2(ScalarChanAndVeseDenseLevelSetImageFilter self, double Lambda2)"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_SetLambda2(self, Lambda2)

    def GetLambda2(self):
        r"""GetLambda2(ScalarChanAndVeseDenseLevelSetImageFilter self) -> double"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_GetLambda2(self)

    def SetEpsilon(self, Epsilon):
        r"""SetEpsilon(ScalarChanAndVeseDenseLevelSetImageFilter self, double Epsilon)"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_SetEpsilon(self, Epsilon)

    def GetEpsilon(self):
        r"""GetEpsilon(ScalarChanAndVeseDenseLevelSetImageFilter self) -> double"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_GetEpsilon(self)

    def SetCurvatureWeight(self, CurvatureWeight):
        r"""SetCurvatureWeight(ScalarChanAndVeseDenseLevelSetImageFilter self, double CurvatureWeight)"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_SetCurvatureWeight(self, CurvatureWeight)

    def GetCurvatureWeight(self):
        r"""GetCurvatureWeight(ScalarChanAndVeseDenseLevelSetImageFilter self) -> double"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_GetCurvatureWeight(self)

    def SetAreaWeight(self, AreaWeight):
        r"""SetAreaWeight(ScalarChanAndVeseDenseLevelSetImageFilter self, double AreaWeight)"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_SetAreaWeight(self, AreaWeight)

    def GetAreaWeight(self):
        r"""GetAreaWeight(ScalarChanAndVeseDenseLevelSetImageFilter self) -> double"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_GetAreaWeight(self)

    def SetReinitializationSmoothingWeight(self, ReinitializationSmoothingWeight):
        r"""SetReinitializationSmoothingWeight(ScalarChanAndVeseDenseLevelSetImageFilter self, double ReinitializationSmoothingWeight)"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_SetReinitializationSmoothingWeight(self, ReinitializationSmoothingWeight)

    def GetReinitializationSmoothingWeight(self):
        r"""GetReinitializationSmoothingWeight(ScalarChanAndVeseDenseLevelSetImageFilter self) -> double"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_GetReinitializationSmoothingWeight(self)

    def SetVolume(self, Volume):
        r"""SetVolume(ScalarChanAndVeseDenseLevelSetImageFilter self, double Volume)"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_SetVolume(self, Volume)

    def GetVolume(self):
        r"""GetVolume(ScalarChanAndVeseDenseLevelSetImageFilter self) -> double"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_GetVolume(self)

    def SetVolumeMatchingWeight(self, VolumeMatchingWeight):
        r"""SetVolumeMatchingWeight(ScalarChanAndVeseDenseLevelSetImageFilter self, double VolumeMatchingWeight)"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_SetVolumeMatchingWeight(self, VolumeMatchingWeight)

    def GetVolumeMatchingWeight(self):
        r"""GetVolumeMatchingWeight(ScalarChanAndVeseDenseLevelSetImageFilter self) -> double"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_GetVolumeMatchingWeight(self)
    AtanRegularizedHeaviside = _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_AtanRegularizedHeaviside
    
    SinRegularizedHeaviside = _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_SinRegularizedHeaviside
    
    Heaviside = _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_Heaviside
    

    def SetHeavisideStepFunction(self, HeavisideStepFunction):
        r"""SetHeavisideStepFunction(ScalarChanAndVeseDenseLevelSetImageFilter self, slicer_itk::simple::ScalarChanAndVeseDenseLevelSetImageFilter::HeavisideStepFunctionType HeavisideStepFunction)"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_SetHeavisideStepFunction(self, HeavisideStepFunction)

    def GetHeavisideStepFunction(self):
        r"""GetHeavisideStepFunction(ScalarChanAndVeseDenseLevelSetImageFilter self) -> slicer_itk::simple::ScalarChanAndVeseDenseLevelSetImageFilter::HeavisideStepFunctionType"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_GetHeavisideStepFunction(self)

    def SetUseImageSpacing(self, UseImageSpacing):
        r"""SetUseImageSpacing(ScalarChanAndVeseDenseLevelSetImageFilter self, bool UseImageSpacing)"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_SetUseImageSpacing(self, UseImageSpacing)

    def UseImageSpacingOn(self):
        r"""UseImageSpacingOn(ScalarChanAndVeseDenseLevelSetImageFilter self)"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_UseImageSpacingOn(self)

    def UseImageSpacingOff(self):
        r"""UseImageSpacingOff(ScalarChanAndVeseDenseLevelSetImageFilter self)"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_UseImageSpacingOff(self)

    def GetUseImageSpacing(self):
        r"""GetUseImageSpacing(ScalarChanAndVeseDenseLevelSetImageFilter self) -> bool"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_GetUseImageSpacing(self)

    def GetElapsedIterations(self):
        r"""GetElapsedIterations(ScalarChanAndVeseDenseLevelSetImageFilter self) -> uint32_t"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_GetElapsedIterations(self)

    def GetRMSChange(self):
        r"""GetRMSChange(ScalarChanAndVeseDenseLevelSetImageFilter self) -> double"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_GetRMSChange(self)

    def GetName(self):
        r"""GetName(ScalarChanAndVeseDenseLevelSetImageFilter self) -> std::string"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ScalarChanAndVeseDenseLevelSetImageFilter self) -> std::string"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter___str__(self)

    def Execute(self, initialImage, featureImage):
        r"""Execute(ScalarChanAndVeseDenseLevelSetImageFilter self, Image initialImage, Image featureImage) -> Image"""
        return _SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_Execute(self, initialImage, featureImage)

# Register ScalarChanAndVeseDenseLevelSetImageFilter in _SimpleITK:
_SimpleITK.ScalarChanAndVeseDenseLevelSetImageFilter_swigregister(ScalarChanAndVeseDenseLevelSetImageFilter)

def ScalarChanAndVeseDenseLevelSet(*args, **kwargs):
    r"""ScalarChanAndVeseDenseLevelSet(Image initialImage, Image featureImage, double maximumRMSError=0.02, uint32_t numberOfIterations=1000, double lambda1=1.0, double lambda2=1.0, double epsilon=1.0, double curvatureWeight=1.0, double areaWeight=0.0, double reinitializationSmoothingWeight=0.0, double volume=0.0, double volumeMatchingWeight=0.0, slicer_itk::simple::ScalarChanAndVeseDenseLevelSetImageFilter::HeavisideStepFunctionType heavisideStepFunction=AtanRegularizedHeaviside, bool useImageSpacing=True) -> Image"""
    return _SimpleITK.ScalarChanAndVeseDenseLevelSet(*args, **kwargs)
class ScalarConnectedComponentImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ScalarConnectedComponentImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ScalarConnectedComponentImageFilter

    def __init__(self):
        r"""__init__(ScalarConnectedComponentImageFilter self) -> ScalarConnectedComponentImageFilter"""
        _SimpleITK.ScalarConnectedComponentImageFilter_swiginit(self, _SimpleITK.new_ScalarConnectedComponentImageFilter())

    def SetDistanceThreshold(self, DistanceThreshold):
        r"""SetDistanceThreshold(ScalarConnectedComponentImageFilter self, double DistanceThreshold)"""
        return _SimpleITK.ScalarConnectedComponentImageFilter_SetDistanceThreshold(self, DistanceThreshold)

    def GetDistanceThreshold(self):
        r"""GetDistanceThreshold(ScalarConnectedComponentImageFilter self) -> double"""
        return _SimpleITK.ScalarConnectedComponentImageFilter_GetDistanceThreshold(self)

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(ScalarConnectedComponentImageFilter self, bool FullyConnected)"""
        return _SimpleITK.ScalarConnectedComponentImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(ScalarConnectedComponentImageFilter self)"""
        return _SimpleITK.ScalarConnectedComponentImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(ScalarConnectedComponentImageFilter self)"""
        return _SimpleITK.ScalarConnectedComponentImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(ScalarConnectedComponentImageFilter self) -> bool"""
        return _SimpleITK.ScalarConnectedComponentImageFilter_GetFullyConnected(self)

    def GetName(self):
        r"""GetName(ScalarConnectedComponentImageFilter self) -> std::string"""
        return _SimpleITK.ScalarConnectedComponentImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ScalarConnectedComponentImageFilter self) -> std::string"""
        return _SimpleITK.ScalarConnectedComponentImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(ScalarConnectedComponentImageFilter self, Image image, Image maskImage) -> Image
        Execute(ScalarConnectedComponentImageFilter self, Image image) -> Image
        """
        return _SimpleITK.ScalarConnectedComponentImageFilter_Execute(self, *args)

# Register ScalarConnectedComponentImageFilter in _SimpleITK:
_SimpleITK.ScalarConnectedComponentImageFilter_swigregister(ScalarConnectedComponentImageFilter)

def ScalarConnectedComponent(*args):
    r"""
    ScalarConnectedComponent(Image image, Image maskImage, double distanceThreshold=0.0, bool fullyConnected=False) -> Image
    ScalarConnectedComponent(Image image, double distanceThreshold=0.0, bool fullyConnected=False) -> Image
    """
    return _SimpleITK.ScalarConnectedComponent(*args)
class ScalarImageKmeansImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ScalarImageKmeansImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ScalarImageKmeansImageFilter

    def __init__(self):
        r"""__init__(ScalarImageKmeansImageFilter self) -> ScalarImageKmeansImageFilter"""
        _SimpleITK.ScalarImageKmeansImageFilter_swiginit(self, _SimpleITK.new_ScalarImageKmeansImageFilter())

    def SetClassWithInitialMean(self, ClassWithInitialMean):
        r"""SetClassWithInitialMean(ScalarImageKmeansImageFilter self, VectorDouble ClassWithInitialMean)"""
        return _SimpleITK.ScalarImageKmeansImageFilter_SetClassWithInitialMean(self, ClassWithInitialMean)

    def GetClassWithInitialMean(self):
        r"""GetClassWithInitialMean(ScalarImageKmeansImageFilter self) -> VectorDouble"""
        return _SimpleITK.ScalarImageKmeansImageFilter_GetClassWithInitialMean(self)

    def SetUseNonContiguousLabels(self, UseNonContiguousLabels):
        r"""SetUseNonContiguousLabels(ScalarImageKmeansImageFilter self, bool UseNonContiguousLabels)"""
        return _SimpleITK.ScalarImageKmeansImageFilter_SetUseNonContiguousLabels(self, UseNonContiguousLabels)

    def UseNonContiguousLabelsOn(self):
        r"""UseNonContiguousLabelsOn(ScalarImageKmeansImageFilter self)"""
        return _SimpleITK.ScalarImageKmeansImageFilter_UseNonContiguousLabelsOn(self)

    def UseNonContiguousLabelsOff(self):
        r"""UseNonContiguousLabelsOff(ScalarImageKmeansImageFilter self)"""
        return _SimpleITK.ScalarImageKmeansImageFilter_UseNonContiguousLabelsOff(self)

    def GetUseNonContiguousLabels(self):
        r"""GetUseNonContiguousLabels(ScalarImageKmeansImageFilter self) -> bool"""
        return _SimpleITK.ScalarImageKmeansImageFilter_GetUseNonContiguousLabels(self)

    def GetFinalMeans(self):
        r"""GetFinalMeans(ScalarImageKmeansImageFilter self) -> VectorDouble"""
        return _SimpleITK.ScalarImageKmeansImageFilter_GetFinalMeans(self)

    def GetName(self):
        r"""GetName(ScalarImageKmeansImageFilter self) -> std::string"""
        return _SimpleITK.ScalarImageKmeansImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ScalarImageKmeansImageFilter self) -> std::string"""
        return _SimpleITK.ScalarImageKmeansImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ScalarImageKmeansImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ScalarImageKmeansImageFilter_Execute(self, image1)

# Register ScalarImageKmeansImageFilter in _SimpleITK:
_SimpleITK.ScalarImageKmeansImageFilter_swigregister(ScalarImageKmeansImageFilter)

def ScalarImageKmeans(*args, **kwargs):
    r"""ScalarImageKmeans(Image image1, VectorDouble classWithInitialMean=std::vector< double >(), bool useNonContiguousLabels=False) -> Image"""
    return _SimpleITK.ScalarImageKmeans(*args, **kwargs)
class ScalarToRGBColormapImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ScalarToRGBColormapImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ScalarToRGBColormapImageFilter

    def __init__(self):
        r"""__init__(ScalarToRGBColormapImageFilter self) -> ScalarToRGBColormapImageFilter"""
        _SimpleITK.ScalarToRGBColormapImageFilter_swiginit(self, _SimpleITK.new_ScalarToRGBColormapImageFilter())
    Red = _SimpleITK.ScalarToRGBColormapImageFilter_Red
    
    Green = _SimpleITK.ScalarToRGBColormapImageFilter_Green
    
    Blue = _SimpleITK.ScalarToRGBColormapImageFilter_Blue
    
    Grey = _SimpleITK.ScalarToRGBColormapImageFilter_Grey
    
    Hot = _SimpleITK.ScalarToRGBColormapImageFilter_Hot
    
    Cool = _SimpleITK.ScalarToRGBColormapImageFilter_Cool
    
    Spring = _SimpleITK.ScalarToRGBColormapImageFilter_Spring
    
    Summer = _SimpleITK.ScalarToRGBColormapImageFilter_Summer
    
    Autumn = _SimpleITK.ScalarToRGBColormapImageFilter_Autumn
    
    Winter = _SimpleITK.ScalarToRGBColormapImageFilter_Winter
    
    Copper = _SimpleITK.ScalarToRGBColormapImageFilter_Copper
    
    Jet = _SimpleITK.ScalarToRGBColormapImageFilter_Jet
    
    HSV = _SimpleITK.ScalarToRGBColormapImageFilter_HSV
    
    OverUnder = _SimpleITK.ScalarToRGBColormapImageFilter_OverUnder
    

    def SetColormap(self, Colormap):
        r"""SetColormap(ScalarToRGBColormapImageFilter self, slicer_itk::simple::ScalarToRGBColormapImageFilter::ColormapType Colormap)"""
        return _SimpleITK.ScalarToRGBColormapImageFilter_SetColormap(self, Colormap)

    def GetColormap(self):
        r"""GetColormap(ScalarToRGBColormapImageFilter self) -> slicer_itk::simple::ScalarToRGBColormapImageFilter::ColormapType"""
        return _SimpleITK.ScalarToRGBColormapImageFilter_GetColormap(self)

    def SetUseInputImageExtremaForScaling(self, UseInputImageExtremaForScaling):
        r"""SetUseInputImageExtremaForScaling(ScalarToRGBColormapImageFilter self, bool UseInputImageExtremaForScaling)"""
        return _SimpleITK.ScalarToRGBColormapImageFilter_SetUseInputImageExtremaForScaling(self, UseInputImageExtremaForScaling)

    def UseInputImageExtremaForScalingOn(self):
        r"""UseInputImageExtremaForScalingOn(ScalarToRGBColormapImageFilter self)"""
        return _SimpleITK.ScalarToRGBColormapImageFilter_UseInputImageExtremaForScalingOn(self)

    def UseInputImageExtremaForScalingOff(self):
        r"""UseInputImageExtremaForScalingOff(ScalarToRGBColormapImageFilter self)"""
        return _SimpleITK.ScalarToRGBColormapImageFilter_UseInputImageExtremaForScalingOff(self)

    def GetUseInputImageExtremaForScaling(self):
        r"""GetUseInputImageExtremaForScaling(ScalarToRGBColormapImageFilter self) -> bool"""
        return _SimpleITK.ScalarToRGBColormapImageFilter_GetUseInputImageExtremaForScaling(self)

    def GetName(self):
        r"""GetName(ScalarToRGBColormapImageFilter self) -> std::string"""
        return _SimpleITK.ScalarToRGBColormapImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ScalarToRGBColormapImageFilter self) -> std::string"""
        return _SimpleITK.ScalarToRGBColormapImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ScalarToRGBColormapImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ScalarToRGBColormapImageFilter_Execute(self, image1)

# Register ScalarToRGBColormapImageFilter in _SimpleITK:
_SimpleITK.ScalarToRGBColormapImageFilter_swigregister(ScalarToRGBColormapImageFilter)

def ScalarToRGBColormap(*args, **kwargs):
    r"""ScalarToRGBColormap(Image image1, slicer_itk::simple::ScalarToRGBColormapImageFilter::ColormapType colormap=Grey, bool useInputImageExtremaForScaling=True) -> Image"""
    return _SimpleITK.ScalarToRGBColormap(*args, **kwargs)
class ShanbhagThresholdImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ShanbhagThresholdImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ShanbhagThresholdImageFilter

    def __init__(self):
        r"""__init__(ShanbhagThresholdImageFilter self) -> ShanbhagThresholdImageFilter"""
        _SimpleITK.ShanbhagThresholdImageFilter_swiginit(self, _SimpleITK.new_ShanbhagThresholdImageFilter())

    def SetInsideValue(self, InsideValue):
        r"""SetInsideValue(ShanbhagThresholdImageFilter self, uint8_t InsideValue)"""
        return _SimpleITK.ShanbhagThresholdImageFilter_SetInsideValue(self, InsideValue)

    def GetInsideValue(self):
        r"""GetInsideValue(ShanbhagThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.ShanbhagThresholdImageFilter_GetInsideValue(self)

    def SetOutsideValue(self, OutsideValue):
        r"""SetOutsideValue(ShanbhagThresholdImageFilter self, uint8_t OutsideValue)"""
        return _SimpleITK.ShanbhagThresholdImageFilter_SetOutsideValue(self, OutsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(ShanbhagThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.ShanbhagThresholdImageFilter_GetOutsideValue(self)

    def SetNumberOfHistogramBins(self, NumberOfHistogramBins):
        r"""SetNumberOfHistogramBins(ShanbhagThresholdImageFilter self, uint32_t NumberOfHistogramBins)"""
        return _SimpleITK.ShanbhagThresholdImageFilter_SetNumberOfHistogramBins(self, NumberOfHistogramBins)

    def GetNumberOfHistogramBins(self):
        r"""GetNumberOfHistogramBins(ShanbhagThresholdImageFilter self) -> uint32_t"""
        return _SimpleITK.ShanbhagThresholdImageFilter_GetNumberOfHistogramBins(self)

    def SetMaskOutput(self, MaskOutput):
        r"""SetMaskOutput(ShanbhagThresholdImageFilter self, bool MaskOutput)"""
        return _SimpleITK.ShanbhagThresholdImageFilter_SetMaskOutput(self, MaskOutput)

    def MaskOutputOn(self):
        r"""MaskOutputOn(ShanbhagThresholdImageFilter self)"""
        return _SimpleITK.ShanbhagThresholdImageFilter_MaskOutputOn(self)

    def MaskOutputOff(self):
        r"""MaskOutputOff(ShanbhagThresholdImageFilter self)"""
        return _SimpleITK.ShanbhagThresholdImageFilter_MaskOutputOff(self)

    def GetMaskOutput(self):
        r"""GetMaskOutput(ShanbhagThresholdImageFilter self) -> bool"""
        return _SimpleITK.ShanbhagThresholdImageFilter_GetMaskOutput(self)

    def SetMaskValue(self, MaskValue):
        r"""SetMaskValue(ShanbhagThresholdImageFilter self, uint8_t MaskValue)"""
        return _SimpleITK.ShanbhagThresholdImageFilter_SetMaskValue(self, MaskValue)

    def GetMaskValue(self):
        r"""GetMaskValue(ShanbhagThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.ShanbhagThresholdImageFilter_GetMaskValue(self)

    def GetThreshold(self):
        r"""GetThreshold(ShanbhagThresholdImageFilter self) -> double"""
        return _SimpleITK.ShanbhagThresholdImageFilter_GetThreshold(self)

    def GetName(self):
        r"""GetName(ShanbhagThresholdImageFilter self) -> std::string"""
        return _SimpleITK.ShanbhagThresholdImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ShanbhagThresholdImageFilter self) -> std::string"""
        return _SimpleITK.ShanbhagThresholdImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(ShanbhagThresholdImageFilter self, Image image, Image maskImage) -> Image
        Execute(ShanbhagThresholdImageFilter self, Image image) -> Image
        """
        return _SimpleITK.ShanbhagThresholdImageFilter_Execute(self, *args)

# Register ShanbhagThresholdImageFilter in _SimpleITK:
_SimpleITK.ShanbhagThresholdImageFilter_swigregister(ShanbhagThresholdImageFilter)

def ShanbhagThreshold(*args):
    r"""
    ShanbhagThreshold(Image image, Image maskImage, uint8_t insideValue=1, uint8_t outsideValue=0, uint32_t numberOfHistogramBins=256, bool maskOutput=True, uint8_t maskValue=255) -> Image
    ShanbhagThreshold(Image image, uint8_t insideValue=1, uint8_t outsideValue=0, uint32_t numberOfHistogramBins=256, bool maskOutput=True, uint8_t maskValue=255) -> Image
    """
    return _SimpleITK.ShanbhagThreshold(*args)
class ShapeDetectionLevelSetImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ShapeDetectionLevelSetImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ShapeDetectionLevelSetImageFilter

    def __init__(self):
        r"""__init__(ShapeDetectionLevelSetImageFilter self) -> ShapeDetectionLevelSetImageFilter"""
        _SimpleITK.ShapeDetectionLevelSetImageFilter_swiginit(self, _SimpleITK.new_ShapeDetectionLevelSetImageFilter())

    def SetMaximumRMSError(self, MaximumRMSError):
        r"""SetMaximumRMSError(ShapeDetectionLevelSetImageFilter self, double MaximumRMSError)"""
        return _SimpleITK.ShapeDetectionLevelSetImageFilter_SetMaximumRMSError(self, MaximumRMSError)

    def GetMaximumRMSError(self):
        r"""GetMaximumRMSError(ShapeDetectionLevelSetImageFilter self) -> double"""
        return _SimpleITK.ShapeDetectionLevelSetImageFilter_GetMaximumRMSError(self)

    def SetPropagationScaling(self, PropagationScaling):
        r"""SetPropagationScaling(ShapeDetectionLevelSetImageFilter self, double PropagationScaling)"""
        return _SimpleITK.ShapeDetectionLevelSetImageFilter_SetPropagationScaling(self, PropagationScaling)

    def GetPropagationScaling(self):
        r"""GetPropagationScaling(ShapeDetectionLevelSetImageFilter self) -> double"""
        return _SimpleITK.ShapeDetectionLevelSetImageFilter_GetPropagationScaling(self)

    def SetCurvatureScaling(self, CurvatureScaling):
        r"""SetCurvatureScaling(ShapeDetectionLevelSetImageFilter self, double CurvatureScaling)"""
        return _SimpleITK.ShapeDetectionLevelSetImageFilter_SetCurvatureScaling(self, CurvatureScaling)

    def GetCurvatureScaling(self):
        r"""GetCurvatureScaling(ShapeDetectionLevelSetImageFilter self) -> double"""
        return _SimpleITK.ShapeDetectionLevelSetImageFilter_GetCurvatureScaling(self)

    def SetNumberOfIterations(self, NumberOfIterations):
        r"""SetNumberOfIterations(ShapeDetectionLevelSetImageFilter self, uint32_t NumberOfIterations)"""
        return _SimpleITK.ShapeDetectionLevelSetImageFilter_SetNumberOfIterations(self, NumberOfIterations)

    def GetNumberOfIterations(self):
        r"""GetNumberOfIterations(ShapeDetectionLevelSetImageFilter self) -> uint32_t"""
        return _SimpleITK.ShapeDetectionLevelSetImageFilter_GetNumberOfIterations(self)

    def SetReverseExpansionDirection(self, ReverseExpansionDirection):
        r"""SetReverseExpansionDirection(ShapeDetectionLevelSetImageFilter self, bool ReverseExpansionDirection)"""
        return _SimpleITK.ShapeDetectionLevelSetImageFilter_SetReverseExpansionDirection(self, ReverseExpansionDirection)

    def ReverseExpansionDirectionOn(self):
        r"""ReverseExpansionDirectionOn(ShapeDetectionLevelSetImageFilter self)"""
        return _SimpleITK.ShapeDetectionLevelSetImageFilter_ReverseExpansionDirectionOn(self)

    def ReverseExpansionDirectionOff(self):
        r"""ReverseExpansionDirectionOff(ShapeDetectionLevelSetImageFilter self)"""
        return _SimpleITK.ShapeDetectionLevelSetImageFilter_ReverseExpansionDirectionOff(self)

    def GetReverseExpansionDirection(self):
        r"""GetReverseExpansionDirection(ShapeDetectionLevelSetImageFilter self) -> bool"""
        return _SimpleITK.ShapeDetectionLevelSetImageFilter_GetReverseExpansionDirection(self)

    def GetElapsedIterations(self):
        r"""GetElapsedIterations(ShapeDetectionLevelSetImageFilter self) -> uint32_t"""
        return _SimpleITK.ShapeDetectionLevelSetImageFilter_GetElapsedIterations(self)

    def GetRMSChange(self):
        r"""GetRMSChange(ShapeDetectionLevelSetImageFilter self) -> double"""
        return _SimpleITK.ShapeDetectionLevelSetImageFilter_GetRMSChange(self)

    def GetName(self):
        r"""GetName(ShapeDetectionLevelSetImageFilter self) -> std::string"""
        return _SimpleITK.ShapeDetectionLevelSetImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ShapeDetectionLevelSetImageFilter self) -> std::string"""
        return _SimpleITK.ShapeDetectionLevelSetImageFilter___str__(self)

    def Execute(self, initialImage, featureImage):
        r"""Execute(ShapeDetectionLevelSetImageFilter self, Image initialImage, Image featureImage) -> Image"""
        return _SimpleITK.ShapeDetectionLevelSetImageFilter_Execute(self, initialImage, featureImage)

# Register ShapeDetectionLevelSetImageFilter in _SimpleITK:
_SimpleITK.ShapeDetectionLevelSetImageFilter_swigregister(ShapeDetectionLevelSetImageFilter)

def ShapeDetectionLevelSet(initialImage, featureImage, maximumRMSError=0.02, propagationScaling=1.0, curvatureScaling=1.0, numberOfIterations=1000, reverseExpansionDirection=False):
    r"""ShapeDetectionLevelSet(Image initialImage, Image featureImage, double maximumRMSError=0.02, double propagationScaling=1.0, double curvatureScaling=1.0, uint32_t numberOfIterations=1000, bool reverseExpansionDirection=False) -> Image"""
    return _SimpleITK.ShapeDetectionLevelSet(initialImage, featureImage, maximumRMSError, propagationScaling, curvatureScaling, numberOfIterations, reverseExpansionDirection)
class ShiftScaleImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ShiftScaleImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ShiftScaleImageFilter

    def __init__(self):
        r"""__init__(ShiftScaleImageFilter self) -> ShiftScaleImageFilter"""
        _SimpleITK.ShiftScaleImageFilter_swiginit(self, _SimpleITK.new_ShiftScaleImageFilter())

    def SetShift(self, Shift):
        r"""SetShift(ShiftScaleImageFilter self, double Shift)"""
        return _SimpleITK.ShiftScaleImageFilter_SetShift(self, Shift)

    def GetShift(self):
        r"""GetShift(ShiftScaleImageFilter self) -> double"""
        return _SimpleITK.ShiftScaleImageFilter_GetShift(self)

    def SetScale(self, Scale):
        r"""SetScale(ShiftScaleImageFilter self, double Scale)"""
        return _SimpleITK.ShiftScaleImageFilter_SetScale(self, Scale)

    def GetScale(self):
        r"""GetScale(ShiftScaleImageFilter self) -> double"""
        return _SimpleITK.ShiftScaleImageFilter_GetScale(self)

    def SetOutputPixelType(self, OutputPixelType):
        r"""SetOutputPixelType(ShiftScaleImageFilter self, slicer_itk::simple::PixelIDValueEnum OutputPixelType)"""
        return _SimpleITK.ShiftScaleImageFilter_SetOutputPixelType(self, OutputPixelType)

    def GetOutputPixelType(self):
        r"""GetOutputPixelType(ShiftScaleImageFilter self) -> slicer_itk::simple::PixelIDValueEnum"""
        return _SimpleITK.ShiftScaleImageFilter_GetOutputPixelType(self)

    def GetUnderflowCount(self):
        r"""GetUnderflowCount(ShiftScaleImageFilter self) -> int64_t"""
        return _SimpleITK.ShiftScaleImageFilter_GetUnderflowCount(self)

    def GetOverflowCount(self):
        r"""GetOverflowCount(ShiftScaleImageFilter self) -> int64_t"""
        return _SimpleITK.ShiftScaleImageFilter_GetOverflowCount(self)

    def GetName(self):
        r"""GetName(ShiftScaleImageFilter self) -> std::string"""
        return _SimpleITK.ShiftScaleImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ShiftScaleImageFilter self) -> std::string"""
        return _SimpleITK.ShiftScaleImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ShiftScaleImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ShiftScaleImageFilter_Execute(self, image1)

# Register ShiftScaleImageFilter in _SimpleITK:
_SimpleITK.ShiftScaleImageFilter_swigregister(ShiftScaleImageFilter)

def ShiftScale(*args, **kwargs):
    r"""ShiftScale(Image image1, double shift=0, double scale=1.0, slicer_itk::simple::PixelIDValueEnum outputPixelType=sitkUnknown) -> Image"""
    return _SimpleITK.ShiftScale(*args, **kwargs)
class ShotNoiseImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ShotNoiseImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ShotNoiseImageFilter

    def __init__(self):
        r"""__init__(ShotNoiseImageFilter self) -> ShotNoiseImageFilter"""
        _SimpleITK.ShotNoiseImageFilter_swiginit(self, _SimpleITK.new_ShotNoiseImageFilter())

    def SetScale(self, Scale):
        r"""SetScale(ShotNoiseImageFilter self, double Scale)"""
        return _SimpleITK.ShotNoiseImageFilter_SetScale(self, Scale)

    def GetScale(self):
        r"""GetScale(ShotNoiseImageFilter self) -> double"""
        return _SimpleITK.ShotNoiseImageFilter_GetScale(self)

    def SetSeed(self, Seed):
        r"""SetSeed(ShotNoiseImageFilter self, uint32_t Seed)"""
        return _SimpleITK.ShotNoiseImageFilter_SetSeed(self, Seed)

    def GetSeed(self):
        r"""GetSeed(ShotNoiseImageFilter self) -> uint32_t"""
        return _SimpleITK.ShotNoiseImageFilter_GetSeed(self)

    def GetName(self):
        r"""GetName(ShotNoiseImageFilter self) -> std::string"""
        return _SimpleITK.ShotNoiseImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ShotNoiseImageFilter self) -> std::string"""
        return _SimpleITK.ShotNoiseImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ShotNoiseImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ShotNoiseImageFilter_Execute(self, image1)

# Register ShotNoiseImageFilter in _SimpleITK:
_SimpleITK.ShotNoiseImageFilter_swigregister(ShotNoiseImageFilter)

def ShotNoise(*args, **kwargs):
    r"""ShotNoise(Image image1, double scale=1.0, uint32_t seed=(uint32_t) slicer_itk::simple::sitkWallClock) -> Image"""
    return _SimpleITK.ShotNoise(*args, **kwargs)
class ShrinkImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ShrinkImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ShrinkImageFilter

    def __init__(self):
        r"""__init__(ShrinkImageFilter self) -> ShrinkImageFilter"""
        _SimpleITK.ShrinkImageFilter_swiginit(self, _SimpleITK.new_ShrinkImageFilter())

    def SetShrinkFactor(self, s):
        r"""SetShrinkFactor(ShrinkImageFilter self, unsigned int s)"""
        return _SimpleITK.ShrinkImageFilter_SetShrinkFactor(self, s)

    def SetShrinkFactors(self, ShrinkFactors):
        r"""SetShrinkFactors(ShrinkImageFilter self, VectorUInt32 ShrinkFactors)"""
        return _SimpleITK.ShrinkImageFilter_SetShrinkFactors(self, ShrinkFactors)

    def GetShrinkFactors(self):
        r"""GetShrinkFactors(ShrinkImageFilter self) -> VectorUInt32"""
        return _SimpleITK.ShrinkImageFilter_GetShrinkFactors(self)

    def GetName(self):
        r"""GetName(ShrinkImageFilter self) -> std::string"""
        return _SimpleITK.ShrinkImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ShrinkImageFilter self) -> std::string"""
        return _SimpleITK.ShrinkImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ShrinkImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ShrinkImageFilter_Execute(self, image1)

# Register ShrinkImageFilter in _SimpleITK:
_SimpleITK.ShrinkImageFilter_swigregister(ShrinkImageFilter)

def Shrink(*args, **kwargs):
    r"""Shrink(Image image1, VectorUInt32 shrinkFactors=std::vector< unsigned int >(3, 1)) -> Image"""
    return _SimpleITK.Shrink(*args, **kwargs)
class SigmoidImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::SigmoidImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_SigmoidImageFilter

    def __init__(self):
        r"""__init__(SigmoidImageFilter self) -> SigmoidImageFilter"""
        _SimpleITK.SigmoidImageFilter_swiginit(self, _SimpleITK.new_SigmoidImageFilter())

    def SetAlpha(self, Alpha):
        r"""SetAlpha(SigmoidImageFilter self, double Alpha)"""
        return _SimpleITK.SigmoidImageFilter_SetAlpha(self, Alpha)

    def GetAlpha(self):
        r"""GetAlpha(SigmoidImageFilter self) -> double"""
        return _SimpleITK.SigmoidImageFilter_GetAlpha(self)

    def SetBeta(self, Beta):
        r"""SetBeta(SigmoidImageFilter self, double Beta)"""
        return _SimpleITK.SigmoidImageFilter_SetBeta(self, Beta)

    def GetBeta(self):
        r"""GetBeta(SigmoidImageFilter self) -> double"""
        return _SimpleITK.SigmoidImageFilter_GetBeta(self)

    def SetOutputMaximum(self, OutputMaximum):
        r"""SetOutputMaximum(SigmoidImageFilter self, double OutputMaximum)"""
        return _SimpleITK.SigmoidImageFilter_SetOutputMaximum(self, OutputMaximum)

    def GetOutputMaximum(self):
        r"""GetOutputMaximum(SigmoidImageFilter self) -> double"""
        return _SimpleITK.SigmoidImageFilter_GetOutputMaximum(self)

    def SetOutputMinimum(self, OutputMinimum):
        r"""SetOutputMinimum(SigmoidImageFilter self, double OutputMinimum)"""
        return _SimpleITK.SigmoidImageFilter_SetOutputMinimum(self, OutputMinimum)

    def GetOutputMinimum(self):
        r"""GetOutputMinimum(SigmoidImageFilter self) -> double"""
        return _SimpleITK.SigmoidImageFilter_GetOutputMinimum(self)

    def GetName(self):
        r"""GetName(SigmoidImageFilter self) -> std::string"""
        return _SimpleITK.SigmoidImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(SigmoidImageFilter self) -> std::string"""
        return _SimpleITK.SigmoidImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(SigmoidImageFilter self, Image image1) -> Image"""
        return _SimpleITK.SigmoidImageFilter_Execute(self, image1)

# Register SigmoidImageFilter in _SimpleITK:
_SimpleITK.SigmoidImageFilter_swigregister(SigmoidImageFilter)

def Sigmoid(image1, alpha=1, beta=0, outputMaximum=255, outputMinimum=0):
    r"""Sigmoid(Image image1, double alpha=1, double beta=0, double outputMaximum=255, double outputMinimum=0) -> Image"""
    return _SimpleITK.Sigmoid(image1, alpha, beta, outputMaximum, outputMinimum)
class SignedDanielssonDistanceMapImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::SignedDanielssonDistanceMapImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_SignedDanielssonDistanceMapImageFilter

    def __init__(self):
        r"""__init__(SignedDanielssonDistanceMapImageFilter self) -> SignedDanielssonDistanceMapImageFilter"""
        _SimpleITK.SignedDanielssonDistanceMapImageFilter_swiginit(self, _SimpleITK.new_SignedDanielssonDistanceMapImageFilter())

    def SetInsideIsPositive(self, InsideIsPositive):
        r"""SetInsideIsPositive(SignedDanielssonDistanceMapImageFilter self, bool InsideIsPositive)"""
        return _SimpleITK.SignedDanielssonDistanceMapImageFilter_SetInsideIsPositive(self, InsideIsPositive)

    def InsideIsPositiveOn(self):
        r"""InsideIsPositiveOn(SignedDanielssonDistanceMapImageFilter self)"""
        return _SimpleITK.SignedDanielssonDistanceMapImageFilter_InsideIsPositiveOn(self)

    def InsideIsPositiveOff(self):
        r"""InsideIsPositiveOff(SignedDanielssonDistanceMapImageFilter self)"""
        return _SimpleITK.SignedDanielssonDistanceMapImageFilter_InsideIsPositiveOff(self)

    def GetInsideIsPositive(self):
        r"""GetInsideIsPositive(SignedDanielssonDistanceMapImageFilter self) -> bool"""
        return _SimpleITK.SignedDanielssonDistanceMapImageFilter_GetInsideIsPositive(self)

    def SetSquaredDistance(self, SquaredDistance):
        r"""SetSquaredDistance(SignedDanielssonDistanceMapImageFilter self, bool SquaredDistance)"""
        return _SimpleITK.SignedDanielssonDistanceMapImageFilter_SetSquaredDistance(self, SquaredDistance)

    def SquaredDistanceOn(self):
        r"""SquaredDistanceOn(SignedDanielssonDistanceMapImageFilter self)"""
        return _SimpleITK.SignedDanielssonDistanceMapImageFilter_SquaredDistanceOn(self)

    def SquaredDistanceOff(self):
        r"""SquaredDistanceOff(SignedDanielssonDistanceMapImageFilter self)"""
        return _SimpleITK.SignedDanielssonDistanceMapImageFilter_SquaredDistanceOff(self)

    def GetSquaredDistance(self):
        r"""GetSquaredDistance(SignedDanielssonDistanceMapImageFilter self) -> bool"""
        return _SimpleITK.SignedDanielssonDistanceMapImageFilter_GetSquaredDistance(self)

    def SetUseImageSpacing(self, UseImageSpacing):
        r"""SetUseImageSpacing(SignedDanielssonDistanceMapImageFilter self, bool UseImageSpacing)"""
        return _SimpleITK.SignedDanielssonDistanceMapImageFilter_SetUseImageSpacing(self, UseImageSpacing)

    def UseImageSpacingOn(self):
        r"""UseImageSpacingOn(SignedDanielssonDistanceMapImageFilter self)"""
        return _SimpleITK.SignedDanielssonDistanceMapImageFilter_UseImageSpacingOn(self)

    def UseImageSpacingOff(self):
        r"""UseImageSpacingOff(SignedDanielssonDistanceMapImageFilter self)"""
        return _SimpleITK.SignedDanielssonDistanceMapImageFilter_UseImageSpacingOff(self)

    def GetUseImageSpacing(self):
        r"""GetUseImageSpacing(SignedDanielssonDistanceMapImageFilter self) -> bool"""
        return _SimpleITK.SignedDanielssonDistanceMapImageFilter_GetUseImageSpacing(self)

    def GetVoronoiMap(self):
        r"""GetVoronoiMap(SignedDanielssonDistanceMapImageFilter self) -> Image"""
        return _SimpleITK.SignedDanielssonDistanceMapImageFilter_GetVoronoiMap(self)

    def GetVectorDistanceMap(self):
        r"""GetVectorDistanceMap(SignedDanielssonDistanceMapImageFilter self) -> Image"""
        return _SimpleITK.SignedDanielssonDistanceMapImageFilter_GetVectorDistanceMap(self)

    def GetName(self):
        r"""GetName(SignedDanielssonDistanceMapImageFilter self) -> std::string"""
        return _SimpleITK.SignedDanielssonDistanceMapImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(SignedDanielssonDistanceMapImageFilter self) -> std::string"""
        return _SimpleITK.SignedDanielssonDistanceMapImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(SignedDanielssonDistanceMapImageFilter self, Image image1) -> Image"""
        return _SimpleITK.SignedDanielssonDistanceMapImageFilter_Execute(self, image1)

# Register SignedDanielssonDistanceMapImageFilter in _SimpleITK:
_SimpleITK.SignedDanielssonDistanceMapImageFilter_swigregister(SignedDanielssonDistanceMapImageFilter)

def SignedDanielssonDistanceMap(image1, insideIsPositive=False, squaredDistance=False, useImageSpacing=False):
    r"""SignedDanielssonDistanceMap(Image image1, bool insideIsPositive=False, bool squaredDistance=False, bool useImageSpacing=False) -> Image"""
    return _SimpleITK.SignedDanielssonDistanceMap(image1, insideIsPositive, squaredDistance, useImageSpacing)
class SignedMaurerDistanceMapImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::SignedMaurerDistanceMapImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_SignedMaurerDistanceMapImageFilter

    def __init__(self):
        r"""__init__(SignedMaurerDistanceMapImageFilter self) -> SignedMaurerDistanceMapImageFilter"""
        _SimpleITK.SignedMaurerDistanceMapImageFilter_swiginit(self, _SimpleITK.new_SignedMaurerDistanceMapImageFilter())

    def SetInsideIsPositive(self, InsideIsPositive):
        r"""SetInsideIsPositive(SignedMaurerDistanceMapImageFilter self, bool InsideIsPositive)"""
        return _SimpleITK.SignedMaurerDistanceMapImageFilter_SetInsideIsPositive(self, InsideIsPositive)

    def InsideIsPositiveOn(self):
        r"""InsideIsPositiveOn(SignedMaurerDistanceMapImageFilter self)"""
        return _SimpleITK.SignedMaurerDistanceMapImageFilter_InsideIsPositiveOn(self)

    def InsideIsPositiveOff(self):
        r"""InsideIsPositiveOff(SignedMaurerDistanceMapImageFilter self)"""
        return _SimpleITK.SignedMaurerDistanceMapImageFilter_InsideIsPositiveOff(self)

    def GetInsideIsPositive(self):
        r"""GetInsideIsPositive(SignedMaurerDistanceMapImageFilter self) -> bool"""
        return _SimpleITK.SignedMaurerDistanceMapImageFilter_GetInsideIsPositive(self)

    def SetSquaredDistance(self, SquaredDistance):
        r"""SetSquaredDistance(SignedMaurerDistanceMapImageFilter self, bool SquaredDistance)"""
        return _SimpleITK.SignedMaurerDistanceMapImageFilter_SetSquaredDistance(self, SquaredDistance)

    def SquaredDistanceOn(self):
        r"""SquaredDistanceOn(SignedMaurerDistanceMapImageFilter self)"""
        return _SimpleITK.SignedMaurerDistanceMapImageFilter_SquaredDistanceOn(self)

    def SquaredDistanceOff(self):
        r"""SquaredDistanceOff(SignedMaurerDistanceMapImageFilter self)"""
        return _SimpleITK.SignedMaurerDistanceMapImageFilter_SquaredDistanceOff(self)

    def GetSquaredDistance(self):
        r"""GetSquaredDistance(SignedMaurerDistanceMapImageFilter self) -> bool"""
        return _SimpleITK.SignedMaurerDistanceMapImageFilter_GetSquaredDistance(self)

    def SetUseImageSpacing(self, UseImageSpacing):
        r"""SetUseImageSpacing(SignedMaurerDistanceMapImageFilter self, bool UseImageSpacing)"""
        return _SimpleITK.SignedMaurerDistanceMapImageFilter_SetUseImageSpacing(self, UseImageSpacing)

    def UseImageSpacingOn(self):
        r"""UseImageSpacingOn(SignedMaurerDistanceMapImageFilter self)"""
        return _SimpleITK.SignedMaurerDistanceMapImageFilter_UseImageSpacingOn(self)

    def UseImageSpacingOff(self):
        r"""UseImageSpacingOff(SignedMaurerDistanceMapImageFilter self)"""
        return _SimpleITK.SignedMaurerDistanceMapImageFilter_UseImageSpacingOff(self)

    def GetUseImageSpacing(self):
        r"""GetUseImageSpacing(SignedMaurerDistanceMapImageFilter self) -> bool"""
        return _SimpleITK.SignedMaurerDistanceMapImageFilter_GetUseImageSpacing(self)

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(SignedMaurerDistanceMapImageFilter self, double BackgroundValue)"""
        return _SimpleITK.SignedMaurerDistanceMapImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(SignedMaurerDistanceMapImageFilter self) -> double"""
        return _SimpleITK.SignedMaurerDistanceMapImageFilter_GetBackgroundValue(self)

    def GetName(self):
        r"""GetName(SignedMaurerDistanceMapImageFilter self) -> std::string"""
        return _SimpleITK.SignedMaurerDistanceMapImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(SignedMaurerDistanceMapImageFilter self) -> std::string"""
        return _SimpleITK.SignedMaurerDistanceMapImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(SignedMaurerDistanceMapImageFilter self, Image image1) -> Image"""
        return _SimpleITK.SignedMaurerDistanceMapImageFilter_Execute(self, image1)

# Register SignedMaurerDistanceMapImageFilter in _SimpleITK:
_SimpleITK.SignedMaurerDistanceMapImageFilter_swigregister(SignedMaurerDistanceMapImageFilter)

def SignedMaurerDistanceMap(image1, insideIsPositive=False, squaredDistance=True, useImageSpacing=False, backgroundValue=0.0):
    r"""SignedMaurerDistanceMap(Image image1, bool insideIsPositive=False, bool squaredDistance=True, bool useImageSpacing=False, double backgroundValue=0.0) -> Image"""
    return _SimpleITK.SignedMaurerDistanceMap(image1, insideIsPositive, squaredDistance, useImageSpacing, backgroundValue)
class SimilarityIndexImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::SimilarityIndexImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_SimilarityIndexImageFilter

    def __init__(self):
        r"""__init__(SimilarityIndexImageFilter self) -> SimilarityIndexImageFilter"""
        _SimpleITK.SimilarityIndexImageFilter_swiginit(self, _SimpleITK.new_SimilarityIndexImageFilter())

    def GetSimilarityIndex(self):
        r"""GetSimilarityIndex(SimilarityIndexImageFilter self) -> double"""
        return _SimpleITK.SimilarityIndexImageFilter_GetSimilarityIndex(self)

    def GetName(self):
        r"""GetName(SimilarityIndexImageFilter self) -> std::string"""
        return _SimpleITK.SimilarityIndexImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(SimilarityIndexImageFilter self) -> std::string"""
        return _SimpleITK.SimilarityIndexImageFilter___str__(self)

    def Execute(self, image1, image2):
        r"""Execute(SimilarityIndexImageFilter self, Image image1, Image image2)"""
        return _SimpleITK.SimilarityIndexImageFilter_Execute(self, image1, image2)

# Register SimilarityIndexImageFilter in _SimpleITK:
_SimpleITK.SimilarityIndexImageFilter_swigregister(SimilarityIndexImageFilter)
class SimpleContourExtractorImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::SimpleContourExtractorImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_SimpleContourExtractorImageFilter

    def __init__(self):
        r"""__init__(SimpleContourExtractorImageFilter self) -> SimpleContourExtractorImageFilter"""
        _SimpleITK.SimpleContourExtractorImageFilter_swiginit(self, _SimpleITK.new_SimpleContourExtractorImageFilter())

    def SetInputForegroundValue(self, InputForegroundValue):
        r"""SetInputForegroundValue(SimpleContourExtractorImageFilter self, double InputForegroundValue)"""
        return _SimpleITK.SimpleContourExtractorImageFilter_SetInputForegroundValue(self, InputForegroundValue)

    def GetInputForegroundValue(self):
        r"""GetInputForegroundValue(SimpleContourExtractorImageFilter self) -> double"""
        return _SimpleITK.SimpleContourExtractorImageFilter_GetInputForegroundValue(self)

    def SetInputBackgroundValue(self, InputBackgroundValue):
        r"""SetInputBackgroundValue(SimpleContourExtractorImageFilter self, double InputBackgroundValue)"""
        return _SimpleITK.SimpleContourExtractorImageFilter_SetInputBackgroundValue(self, InputBackgroundValue)

    def GetInputBackgroundValue(self):
        r"""GetInputBackgroundValue(SimpleContourExtractorImageFilter self) -> double"""
        return _SimpleITK.SimpleContourExtractorImageFilter_GetInputBackgroundValue(self)

    def SetRadius(self, *args):
        r"""
        SetRadius(SimpleContourExtractorImageFilter self, VectorUInt32 Radius)
        SetRadius(SimpleContourExtractorImageFilter self, unsigned int value)
        """
        return _SimpleITK.SimpleContourExtractorImageFilter_SetRadius(self, *args)

    def GetRadius(self):
        r"""GetRadius(SimpleContourExtractorImageFilter self) -> VectorUInt32"""
        return _SimpleITK.SimpleContourExtractorImageFilter_GetRadius(self)

    def SetOutputForegroundValue(self, OutputForegroundValue):
        r"""SetOutputForegroundValue(SimpleContourExtractorImageFilter self, double OutputForegroundValue)"""
        return _SimpleITK.SimpleContourExtractorImageFilter_SetOutputForegroundValue(self, OutputForegroundValue)

    def GetOutputForegroundValue(self):
        r"""GetOutputForegroundValue(SimpleContourExtractorImageFilter self) -> double"""
        return _SimpleITK.SimpleContourExtractorImageFilter_GetOutputForegroundValue(self)

    def SetOutputBackgroundValue(self, OutputBackgroundValue):
        r"""SetOutputBackgroundValue(SimpleContourExtractorImageFilter self, double OutputBackgroundValue)"""
        return _SimpleITK.SimpleContourExtractorImageFilter_SetOutputBackgroundValue(self, OutputBackgroundValue)

    def GetOutputBackgroundValue(self):
        r"""GetOutputBackgroundValue(SimpleContourExtractorImageFilter self) -> double"""
        return _SimpleITK.SimpleContourExtractorImageFilter_GetOutputBackgroundValue(self)

    def GetName(self):
        r"""GetName(SimpleContourExtractorImageFilter self) -> std::string"""
        return _SimpleITK.SimpleContourExtractorImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(SimpleContourExtractorImageFilter self) -> std::string"""
        return _SimpleITK.SimpleContourExtractorImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(SimpleContourExtractorImageFilter self, Image image1) -> Image"""
        return _SimpleITK.SimpleContourExtractorImageFilter_Execute(self, image1)

# Register SimpleContourExtractorImageFilter in _SimpleITK:
_SimpleITK.SimpleContourExtractorImageFilter_swigregister(SimpleContourExtractorImageFilter)

def SimpleContourExtractor(*args, **kwargs):
    r"""SimpleContourExtractor(Image image1, double inputForegroundValue=1.0, double inputBackgroundValue=0.0, VectorUInt32 radius=std::vector< unsigned int >(3, 1), double outputForegroundValue=1.0, double outputBackgroundValue=0.0) -> Image"""
    return _SimpleITK.SimpleContourExtractor(*args, **kwargs)
class SinImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::SinImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_SinImageFilter

    def __init__(self):
        r"""__init__(SinImageFilter self) -> SinImageFilter"""
        _SimpleITK.SinImageFilter_swiginit(self, _SimpleITK.new_SinImageFilter())

    def GetName(self):
        r"""GetName(SinImageFilter self) -> std::string"""
        return _SimpleITK.SinImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(SinImageFilter self) -> std::string"""
        return _SimpleITK.SinImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(SinImageFilter self, Image image1) -> Image"""
        return _SimpleITK.SinImageFilter_Execute(self, image1)

# Register SinImageFilter in _SimpleITK:
_SimpleITK.SinImageFilter_swigregister(SinImageFilter)

def Sin(image1):
    r"""Sin(Image image1) -> Image"""
    return _SimpleITK.Sin(image1)
class SliceImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::SliceImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_SliceImageFilter

    def __init__(self):
        r"""__init__(SliceImageFilter self) -> SliceImageFilter"""
        _SimpleITK.SliceImageFilter_swiginit(self, _SimpleITK.new_SliceImageFilter())

    def SetStart(self, Start):
        r"""SetStart(SliceImageFilter self, VectorInt32 Start)"""
        return _SimpleITK.SliceImageFilter_SetStart(self, Start)

    def GetStart(self):
        r"""GetStart(SliceImageFilter self) -> VectorInt32"""
        return _SimpleITK.SliceImageFilter_GetStart(self)

    def SetStop(self, Stop):
        r"""SetStop(SliceImageFilter self, VectorInt32 Stop)"""
        return _SimpleITK.SliceImageFilter_SetStop(self, Stop)

    def GetStop(self):
        r"""GetStop(SliceImageFilter self) -> VectorInt32"""
        return _SimpleITK.SliceImageFilter_GetStop(self)

    def SetStep(self, *args):
        r"""
        SetStep(SliceImageFilter self, VectorInt32 Step)
        SetStep(SliceImageFilter self, int value)
        """
        return _SimpleITK.SliceImageFilter_SetStep(self, *args)

    def GetStep(self):
        r"""GetStep(SliceImageFilter self) -> VectorInt32"""
        return _SimpleITK.SliceImageFilter_GetStep(self)

    def GetName(self):
        r"""GetName(SliceImageFilter self) -> std::string"""
        return _SimpleITK.SliceImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(SliceImageFilter self) -> std::string"""
        return _SimpleITK.SliceImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(SliceImageFilter self, Image image1) -> Image"""
        return _SimpleITK.SliceImageFilter_Execute(self, image1)

# Register SliceImageFilter in _SimpleITK:
_SimpleITK.SliceImageFilter_swigregister(SliceImageFilter)

def Slice(*args, **kwargs):
    r"""Slice(Image image1, VectorInt32 start=std::vector< int32_t >(3, 0), VectorInt32 stop=std::vector< int32_t >(3, std::numeric_limits<int32_t>::max()), VectorInt32 step=std::vector< int >(3, 1)) -> Image"""
    return _SimpleITK.Slice(*args, **kwargs)
class SmoothingRecursiveGaussianImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::SmoothingRecursiveGaussianImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_SmoothingRecursiveGaussianImageFilter

    def __init__(self):
        r"""__init__(SmoothingRecursiveGaussianImageFilter self) -> SmoothingRecursiveGaussianImageFilter"""
        _SimpleITK.SmoothingRecursiveGaussianImageFilter_swiginit(self, _SimpleITK.new_SmoothingRecursiveGaussianImageFilter())

    def SetSigma(self, *args):
        r"""
        SetSigma(SmoothingRecursiveGaussianImageFilter self, VectorDouble Sigma)
        SetSigma(SmoothingRecursiveGaussianImageFilter self, double value)
        """
        return _SimpleITK.SmoothingRecursiveGaussianImageFilter_SetSigma(self, *args)

    def GetSigma(self):
        r"""GetSigma(SmoothingRecursiveGaussianImageFilter self) -> VectorDouble"""
        return _SimpleITK.SmoothingRecursiveGaussianImageFilter_GetSigma(self)

    def SetNormalizeAcrossScale(self, NormalizeAcrossScale):
        r"""SetNormalizeAcrossScale(SmoothingRecursiveGaussianImageFilter self, bool NormalizeAcrossScale)"""
        return _SimpleITK.SmoothingRecursiveGaussianImageFilter_SetNormalizeAcrossScale(self, NormalizeAcrossScale)

    def NormalizeAcrossScaleOn(self):
        r"""NormalizeAcrossScaleOn(SmoothingRecursiveGaussianImageFilter self)"""
        return _SimpleITK.SmoothingRecursiveGaussianImageFilter_NormalizeAcrossScaleOn(self)

    def NormalizeAcrossScaleOff(self):
        r"""NormalizeAcrossScaleOff(SmoothingRecursiveGaussianImageFilter self)"""
        return _SimpleITK.SmoothingRecursiveGaussianImageFilter_NormalizeAcrossScaleOff(self)

    def GetNormalizeAcrossScale(self):
        r"""GetNormalizeAcrossScale(SmoothingRecursiveGaussianImageFilter self) -> bool"""
        return _SimpleITK.SmoothingRecursiveGaussianImageFilter_GetNormalizeAcrossScale(self)

    def GetName(self):
        r"""GetName(SmoothingRecursiveGaussianImageFilter self) -> std::string"""
        return _SimpleITK.SmoothingRecursiveGaussianImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(SmoothingRecursiveGaussianImageFilter self) -> std::string"""
        return _SimpleITK.SmoothingRecursiveGaussianImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(SmoothingRecursiveGaussianImageFilter self, Image image1) -> Image"""
        return _SimpleITK.SmoothingRecursiveGaussianImageFilter_Execute(self, image1)

# Register SmoothingRecursiveGaussianImageFilter in _SimpleITK:
_SimpleITK.SmoothingRecursiveGaussianImageFilter_swigregister(SmoothingRecursiveGaussianImageFilter)

def SmoothingRecursiveGaussian(*args):
    r"""
    SmoothingRecursiveGaussian(Image image1, double sigma, bool normalizeAcrossScale=False) -> Image
    SmoothingRecursiveGaussian(Image image1, VectorDouble sigma=std::vector< double >(3,1.0), bool normalizeAcrossScale=False) -> Image
    """
    return _SimpleITK.SmoothingRecursiveGaussian(*args)
class SobelEdgeDetectionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::SobelEdgeDetectionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_SobelEdgeDetectionImageFilter

    def __init__(self):
        r"""__init__(SobelEdgeDetectionImageFilter self) -> SobelEdgeDetectionImageFilter"""
        _SimpleITK.SobelEdgeDetectionImageFilter_swiginit(self, _SimpleITK.new_SobelEdgeDetectionImageFilter())

    def GetName(self):
        r"""GetName(SobelEdgeDetectionImageFilter self) -> std::string"""
        return _SimpleITK.SobelEdgeDetectionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(SobelEdgeDetectionImageFilter self) -> std::string"""
        return _SimpleITK.SobelEdgeDetectionImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(SobelEdgeDetectionImageFilter self, Image image1) -> Image"""
        return _SimpleITK.SobelEdgeDetectionImageFilter_Execute(self, image1)

# Register SobelEdgeDetectionImageFilter in _SimpleITK:
_SimpleITK.SobelEdgeDetectionImageFilter_swigregister(SobelEdgeDetectionImageFilter)

def SobelEdgeDetection(image1):
    r"""SobelEdgeDetection(Image image1) -> Image"""
    return _SimpleITK.SobelEdgeDetection(image1)
class SpeckleNoiseImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::SpeckleNoiseImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_SpeckleNoiseImageFilter

    def __init__(self):
        r"""__init__(SpeckleNoiseImageFilter self) -> SpeckleNoiseImageFilter"""
        _SimpleITK.SpeckleNoiseImageFilter_swiginit(self, _SimpleITK.new_SpeckleNoiseImageFilter())

    def SetStandardDeviation(self, StandardDeviation):
        r"""SetStandardDeviation(SpeckleNoiseImageFilter self, double StandardDeviation)"""
        return _SimpleITK.SpeckleNoiseImageFilter_SetStandardDeviation(self, StandardDeviation)

    def GetStandardDeviation(self):
        r"""GetStandardDeviation(SpeckleNoiseImageFilter self) -> double"""
        return _SimpleITK.SpeckleNoiseImageFilter_GetStandardDeviation(self)

    def SetSeed(self, Seed):
        r"""SetSeed(SpeckleNoiseImageFilter self, uint32_t Seed)"""
        return _SimpleITK.SpeckleNoiseImageFilter_SetSeed(self, Seed)

    def GetSeed(self):
        r"""GetSeed(SpeckleNoiseImageFilter self) -> uint32_t"""
        return _SimpleITK.SpeckleNoiseImageFilter_GetSeed(self)

    def GetName(self):
        r"""GetName(SpeckleNoiseImageFilter self) -> std::string"""
        return _SimpleITK.SpeckleNoiseImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(SpeckleNoiseImageFilter self) -> std::string"""
        return _SimpleITK.SpeckleNoiseImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(SpeckleNoiseImageFilter self, Image image1) -> Image"""
        return _SimpleITK.SpeckleNoiseImageFilter_Execute(self, image1)

# Register SpeckleNoiseImageFilter in _SimpleITK:
_SimpleITK.SpeckleNoiseImageFilter_swigregister(SpeckleNoiseImageFilter)

def SpeckleNoise(*args, **kwargs):
    r"""SpeckleNoise(Image image1, double standardDeviation=1.0, uint32_t seed=(uint32_t) slicer_itk::simple::sitkWallClock) -> Image"""
    return _SimpleITK.SpeckleNoise(*args, **kwargs)
class SqrtImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::SqrtImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_SqrtImageFilter

    def __init__(self):
        r"""__init__(SqrtImageFilter self) -> SqrtImageFilter"""
        _SimpleITK.SqrtImageFilter_swiginit(self, _SimpleITK.new_SqrtImageFilter())

    def GetName(self):
        r"""GetName(SqrtImageFilter self) -> std::string"""
        return _SimpleITK.SqrtImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(SqrtImageFilter self) -> std::string"""
        return _SimpleITK.SqrtImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(SqrtImageFilter self, Image image1) -> Image"""
        return _SimpleITK.SqrtImageFilter_Execute(self, image1)

# Register SqrtImageFilter in _SimpleITK:
_SimpleITK.SqrtImageFilter_swigregister(SqrtImageFilter)

def Sqrt(image1):
    r"""Sqrt(Image image1) -> Image"""
    return _SimpleITK.Sqrt(image1)
class SquareImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::SquareImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_SquareImageFilter

    def __init__(self):
        r"""__init__(SquareImageFilter self) -> SquareImageFilter"""
        _SimpleITK.SquareImageFilter_swiginit(self, _SimpleITK.new_SquareImageFilter())

    def GetName(self):
        r"""GetName(SquareImageFilter self) -> std::string"""
        return _SimpleITK.SquareImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(SquareImageFilter self) -> std::string"""
        return _SimpleITK.SquareImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(SquareImageFilter self, Image image1) -> Image"""
        return _SimpleITK.SquareImageFilter_Execute(self, image1)

# Register SquareImageFilter in _SimpleITK:
_SimpleITK.SquareImageFilter_swigregister(SquareImageFilter)

def Square(image1):
    r"""Square(Image image1) -> Image"""
    return _SimpleITK.Square(image1)
class SquaredDifferenceImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::SquaredDifferenceImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_SquaredDifferenceImageFilter

    def __init__(self):
        r"""__init__(SquaredDifferenceImageFilter self) -> SquaredDifferenceImageFilter"""
        _SimpleITK.SquaredDifferenceImageFilter_swiginit(self, _SimpleITK.new_SquaredDifferenceImageFilter())

    def GetName(self):
        r"""GetName(SquaredDifferenceImageFilter self) -> std::string"""
        return _SimpleITK.SquaredDifferenceImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(SquaredDifferenceImageFilter self) -> std::string"""
        return _SimpleITK.SquaredDifferenceImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(SquaredDifferenceImageFilter self, Image image1, Image image2) -> Image
        Execute(SquaredDifferenceImageFilter self, Image image1, double constant) -> Image
        Execute(SquaredDifferenceImageFilter self, double constant, Image image2) -> Image
        """
        return _SimpleITK.SquaredDifferenceImageFilter_Execute(self, *args)

# Register SquaredDifferenceImageFilter in _SimpleITK:
_SimpleITK.SquaredDifferenceImageFilter_swigregister(SquaredDifferenceImageFilter)

def SquaredDifference(*args):
    r"""
    SquaredDifference(Image image1, Image image2) -> Image
    SquaredDifference(Image image1, double constant) -> Image
    SquaredDifference(double constant, Image image2) -> Image
    """
    return _SimpleITK.SquaredDifference(*args)
class StandardDeviationProjectionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::StandardDeviationProjectionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_StandardDeviationProjectionImageFilter

    def __init__(self):
        r"""__init__(StandardDeviationProjectionImageFilter self) -> StandardDeviationProjectionImageFilter"""
        _SimpleITK.StandardDeviationProjectionImageFilter_swiginit(self, _SimpleITK.new_StandardDeviationProjectionImageFilter())

    def SetProjectionDimension(self, ProjectionDimension):
        r"""SetProjectionDimension(StandardDeviationProjectionImageFilter self, unsigned int ProjectionDimension)"""
        return _SimpleITK.StandardDeviationProjectionImageFilter_SetProjectionDimension(self, ProjectionDimension)

    def GetProjectionDimension(self):
        r"""GetProjectionDimension(StandardDeviationProjectionImageFilter self) -> unsigned int"""
        return _SimpleITK.StandardDeviationProjectionImageFilter_GetProjectionDimension(self)

    def GetName(self):
        r"""GetName(StandardDeviationProjectionImageFilter self) -> std::string"""
        return _SimpleITK.StandardDeviationProjectionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(StandardDeviationProjectionImageFilter self) -> std::string"""
        return _SimpleITK.StandardDeviationProjectionImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(StandardDeviationProjectionImageFilter self, Image image1) -> Image"""
        return _SimpleITK.StandardDeviationProjectionImageFilter_Execute(self, image1)

# Register StandardDeviationProjectionImageFilter in _SimpleITK:
_SimpleITK.StandardDeviationProjectionImageFilter_swigregister(StandardDeviationProjectionImageFilter)

def StandardDeviationProjection(image1, projectionDimension=0):
    r"""StandardDeviationProjection(Image image1, unsigned int projectionDimension=0) -> Image"""
    return _SimpleITK.StandardDeviationProjection(image1, projectionDimension)
class StatisticsImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::StatisticsImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_StatisticsImageFilter

    def __init__(self):
        r"""__init__(StatisticsImageFilter self) -> StatisticsImageFilter"""
        _SimpleITK.StatisticsImageFilter_swiginit(self, _SimpleITK.new_StatisticsImageFilter())

    def GetMinimum(self):
        r"""GetMinimum(StatisticsImageFilter self) -> double"""
        return _SimpleITK.StatisticsImageFilter_GetMinimum(self)

    def GetMaximum(self):
        r"""GetMaximum(StatisticsImageFilter self) -> double"""
        return _SimpleITK.StatisticsImageFilter_GetMaximum(self)

    def GetMean(self):
        r"""GetMean(StatisticsImageFilter self) -> double"""
        return _SimpleITK.StatisticsImageFilter_GetMean(self)

    def GetSigma(self):
        r"""GetSigma(StatisticsImageFilter self) -> double"""
        return _SimpleITK.StatisticsImageFilter_GetSigma(self)

    def GetVariance(self):
        r"""GetVariance(StatisticsImageFilter self) -> double"""
        return _SimpleITK.StatisticsImageFilter_GetVariance(self)

    def GetSum(self):
        r"""GetSum(StatisticsImageFilter self) -> double"""
        return _SimpleITK.StatisticsImageFilter_GetSum(self)

    def GetName(self):
        r"""GetName(StatisticsImageFilter self) -> std::string"""
        return _SimpleITK.StatisticsImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(StatisticsImageFilter self) -> std::string"""
        return _SimpleITK.StatisticsImageFilter___str__(self)

    def Execute(self, image):
        r"""Execute(StatisticsImageFilter self, Image image)"""
        return _SimpleITK.StatisticsImageFilter_Execute(self, image)

# Register StatisticsImageFilter in _SimpleITK:
_SimpleITK.StatisticsImageFilter_swigregister(StatisticsImageFilter)
class StochasticFractalDimensionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::StochasticFractalDimensionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_StochasticFractalDimensionImageFilter

    def __init__(self):
        r"""__init__(StochasticFractalDimensionImageFilter self) -> StochasticFractalDimensionImageFilter"""
        _SimpleITK.StochasticFractalDimensionImageFilter_swiginit(self, _SimpleITK.new_StochasticFractalDimensionImageFilter())

    def SetNeighborhoodRadius(self, *args):
        r"""
        SetNeighborhoodRadius(StochasticFractalDimensionImageFilter self, VectorUInt32 NeighborhoodRadius)
        SetNeighborhoodRadius(StochasticFractalDimensionImageFilter self, unsigned int value)
        """
        return _SimpleITK.StochasticFractalDimensionImageFilter_SetNeighborhoodRadius(self, *args)

    def GetNeighborhoodRadius(self):
        r"""GetNeighborhoodRadius(StochasticFractalDimensionImageFilter self) -> VectorUInt32"""
        return _SimpleITK.StochasticFractalDimensionImageFilter_GetNeighborhoodRadius(self)

    def GetName(self):
        r"""GetName(StochasticFractalDimensionImageFilter self) -> std::string"""
        return _SimpleITK.StochasticFractalDimensionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(StochasticFractalDimensionImageFilter self) -> std::string"""
        return _SimpleITK.StochasticFractalDimensionImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(StochasticFractalDimensionImageFilter self, Image image, Image maskImage) -> Image
        Execute(StochasticFractalDimensionImageFilter self, Image image) -> Image
        """
        return _SimpleITK.StochasticFractalDimensionImageFilter_Execute(self, *args)

# Register StochasticFractalDimensionImageFilter in _SimpleITK:
_SimpleITK.StochasticFractalDimensionImageFilter_swigregister(StochasticFractalDimensionImageFilter)

def StochasticFractalDimension(*args):
    r"""
    StochasticFractalDimension(Image image, Image maskImage, VectorUInt32 neighborhoodRadius=std::vector< unsigned int >(3, 2u)) -> Image
    StochasticFractalDimension(Image image, VectorUInt32 neighborhoodRadius=std::vector< unsigned int >(3, 2u)) -> Image
    """
    return _SimpleITK.StochasticFractalDimension(*args)
class SubtractImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::SubtractImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_SubtractImageFilter

    def __init__(self):
        r"""__init__(SubtractImageFilter self) -> SubtractImageFilter"""
        _SimpleITK.SubtractImageFilter_swiginit(self, _SimpleITK.new_SubtractImageFilter())

    def GetName(self):
        r"""GetName(SubtractImageFilter self) -> std::string"""
        return _SimpleITK.SubtractImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(SubtractImageFilter self) -> std::string"""
        return _SimpleITK.SubtractImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(SubtractImageFilter self, Image image1, Image image2) -> Image
        Execute(SubtractImageFilter self, Image image1, double constant) -> Image
        Execute(SubtractImageFilter self, double constant, Image image2) -> Image
        """
        return _SimpleITK.SubtractImageFilter_Execute(self, *args)

# Register SubtractImageFilter in _SimpleITK:
_SimpleITK.SubtractImageFilter_swigregister(SubtractImageFilter)

def Subtract(*args):
    r"""
    Subtract(Image image1, Image image2) -> Image
    Subtract(Image image1, double constant) -> Image
    Subtract(double constant, Image image2) -> Image
    """
    return _SimpleITK.Subtract(*args)
class SumProjectionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::SumProjectionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_SumProjectionImageFilter

    def __init__(self):
        r"""__init__(SumProjectionImageFilter self) -> SumProjectionImageFilter"""
        _SimpleITK.SumProjectionImageFilter_swiginit(self, _SimpleITK.new_SumProjectionImageFilter())

    def SetProjectionDimension(self, ProjectionDimension):
        r"""SetProjectionDimension(SumProjectionImageFilter self, unsigned int ProjectionDimension)"""
        return _SimpleITK.SumProjectionImageFilter_SetProjectionDimension(self, ProjectionDimension)

    def GetProjectionDimension(self):
        r"""GetProjectionDimension(SumProjectionImageFilter self) -> unsigned int"""
        return _SimpleITK.SumProjectionImageFilter_GetProjectionDimension(self)

    def GetName(self):
        r"""GetName(SumProjectionImageFilter self) -> std::string"""
        return _SimpleITK.SumProjectionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(SumProjectionImageFilter self) -> std::string"""
        return _SimpleITK.SumProjectionImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(SumProjectionImageFilter self, Image image1) -> Image"""
        return _SimpleITK.SumProjectionImageFilter_Execute(self, image1)

# Register SumProjectionImageFilter in _SimpleITK:
_SimpleITK.SumProjectionImageFilter_swigregister(SumProjectionImageFilter)

def SumProjection(image1, projectionDimension=0):
    r"""SumProjection(Image image1, unsigned int projectionDimension=0) -> Image"""
    return _SimpleITK.SumProjection(image1, projectionDimension)
class SymmetricForcesDemonsRegistrationFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::SymmetricForcesDemonsRegistrationFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_SymmetricForcesDemonsRegistrationFilter

    def __init__(self):
        r"""__init__(SymmetricForcesDemonsRegistrationFilter self) -> SymmetricForcesDemonsRegistrationFilter"""
        _SimpleITK.SymmetricForcesDemonsRegistrationFilter_swiginit(self, _SimpleITK.new_SymmetricForcesDemonsRegistrationFilter())

    def SetStandardDeviations(self, *args):
        r"""
        SetStandardDeviations(SymmetricForcesDemonsRegistrationFilter self, VectorDouble StandardDeviations)
        SetStandardDeviations(SymmetricForcesDemonsRegistrationFilter self, double value)
        """
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_SetStandardDeviations(self, *args)

    def GetStandardDeviations(self):
        r"""GetStandardDeviations(SymmetricForcesDemonsRegistrationFilter self) -> VectorDouble"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_GetStandardDeviations(self)

    def SetNumberOfIterations(self, NumberOfIterations):
        r"""SetNumberOfIterations(SymmetricForcesDemonsRegistrationFilter self, uint32_t NumberOfIterations)"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_SetNumberOfIterations(self, NumberOfIterations)

    def GetNumberOfIterations(self):
        r"""GetNumberOfIterations(SymmetricForcesDemonsRegistrationFilter self) -> uint32_t"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_GetNumberOfIterations(self)

    def SetMaximumRMSError(self, MaximumRMSError):
        r"""SetMaximumRMSError(SymmetricForcesDemonsRegistrationFilter self, double MaximumRMSError)"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_SetMaximumRMSError(self, MaximumRMSError)

    def GetMaximumRMSError(self):
        r"""GetMaximumRMSError(SymmetricForcesDemonsRegistrationFilter self) -> double"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_GetMaximumRMSError(self)

    def SetSmoothDisplacementField(self, SmoothDisplacementField):
        r"""SetSmoothDisplacementField(SymmetricForcesDemonsRegistrationFilter self, bool SmoothDisplacementField)"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_SetSmoothDisplacementField(self, SmoothDisplacementField)

    def SmoothDisplacementFieldOn(self):
        r"""SmoothDisplacementFieldOn(SymmetricForcesDemonsRegistrationFilter self)"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_SmoothDisplacementFieldOn(self)

    def SmoothDisplacementFieldOff(self):
        r"""SmoothDisplacementFieldOff(SymmetricForcesDemonsRegistrationFilter self)"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_SmoothDisplacementFieldOff(self)

    def GetSmoothDisplacementField(self):
        r"""GetSmoothDisplacementField(SymmetricForcesDemonsRegistrationFilter self) -> bool"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_GetSmoothDisplacementField(self)

    def SetSmoothUpdateField(self, SmoothUpdateField):
        r"""SetSmoothUpdateField(SymmetricForcesDemonsRegistrationFilter self, bool SmoothUpdateField)"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_SetSmoothUpdateField(self, SmoothUpdateField)

    def SmoothUpdateFieldOn(self):
        r"""SmoothUpdateFieldOn(SymmetricForcesDemonsRegistrationFilter self)"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_SmoothUpdateFieldOn(self)

    def SmoothUpdateFieldOff(self):
        r"""SmoothUpdateFieldOff(SymmetricForcesDemonsRegistrationFilter self)"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_SmoothUpdateFieldOff(self)

    def GetSmoothUpdateField(self):
        r"""GetSmoothUpdateField(SymmetricForcesDemonsRegistrationFilter self) -> bool"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_GetSmoothUpdateField(self)

    def SetUpdateFieldStandardDeviations(self, *args):
        r"""
        SetUpdateFieldStandardDeviations(SymmetricForcesDemonsRegistrationFilter self, VectorDouble UpdateFieldStandardDeviations)
        SetUpdateFieldStandardDeviations(SymmetricForcesDemonsRegistrationFilter self, double value)
        """
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_SetUpdateFieldStandardDeviations(self, *args)

    def GetUpdateFieldStandardDeviations(self):
        r"""GetUpdateFieldStandardDeviations(SymmetricForcesDemonsRegistrationFilter self) -> VectorDouble"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_GetUpdateFieldStandardDeviations(self)

    def SetMaximumKernelWidth(self, MaximumKernelWidth):
        r"""SetMaximumKernelWidth(SymmetricForcesDemonsRegistrationFilter self, unsigned int MaximumKernelWidth)"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_SetMaximumKernelWidth(self, MaximumKernelWidth)

    def GetMaximumKernelWidth(self):
        r"""GetMaximumKernelWidth(SymmetricForcesDemonsRegistrationFilter self) -> unsigned int"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_GetMaximumKernelWidth(self)

    def SetMaximumError(self, MaximumError):
        r"""SetMaximumError(SymmetricForcesDemonsRegistrationFilter self, double MaximumError)"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_SetMaximumError(self, MaximumError)

    def GetMaximumError(self):
        r"""GetMaximumError(SymmetricForcesDemonsRegistrationFilter self) -> double"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_GetMaximumError(self)

    def SetIntensityDifferenceThreshold(self, IntensityDifferenceThreshold):
        r"""SetIntensityDifferenceThreshold(SymmetricForcesDemonsRegistrationFilter self, double IntensityDifferenceThreshold)"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_SetIntensityDifferenceThreshold(self, IntensityDifferenceThreshold)

    def GetIntensityDifferenceThreshold(self):
        r"""GetIntensityDifferenceThreshold(SymmetricForcesDemonsRegistrationFilter self) -> double"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_GetIntensityDifferenceThreshold(self)

    def SetUseImageSpacing(self, UseImageSpacing):
        r"""SetUseImageSpacing(SymmetricForcesDemonsRegistrationFilter self, bool UseImageSpacing)"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_SetUseImageSpacing(self, UseImageSpacing)

    def UseImageSpacingOn(self):
        r"""UseImageSpacingOn(SymmetricForcesDemonsRegistrationFilter self)"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_UseImageSpacingOn(self)

    def UseImageSpacingOff(self):
        r"""UseImageSpacingOff(SymmetricForcesDemonsRegistrationFilter self)"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_UseImageSpacingOff(self)

    def GetUseImageSpacing(self):
        r"""GetUseImageSpacing(SymmetricForcesDemonsRegistrationFilter self) -> bool"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_GetUseImageSpacing(self)

    def GetElapsedIterations(self):
        r"""GetElapsedIterations(SymmetricForcesDemonsRegistrationFilter self) -> uint32_t"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_GetElapsedIterations(self)

    def GetRMSChange(self):
        r"""GetRMSChange(SymmetricForcesDemonsRegistrationFilter self) -> double"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_GetRMSChange(self)

    def GetMetric(self):
        r"""GetMetric(SymmetricForcesDemonsRegistrationFilter self) -> double"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_GetMetric(self)

    def StopRegistration(self):
        r"""StopRegistration(SymmetricForcesDemonsRegistrationFilter self)"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_StopRegistration(self)

    def GetName(self):
        r"""GetName(SymmetricForcesDemonsRegistrationFilter self) -> std::string"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_GetName(self)

    def __str__(self):
        r"""__str__(SymmetricForcesDemonsRegistrationFilter self) -> std::string"""
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(SymmetricForcesDemonsRegistrationFilter self, Image fixedImage, Image movingImage, Image initialDisplacementField) -> Image
        Execute(SymmetricForcesDemonsRegistrationFilter self, Image fixedImage, Image movingImage) -> Image
        """
        return _SimpleITK.SymmetricForcesDemonsRegistrationFilter_Execute(self, *args)

# Register SymmetricForcesDemonsRegistrationFilter in _SimpleITK:
_SimpleITK.SymmetricForcesDemonsRegistrationFilter_swigregister(SymmetricForcesDemonsRegistrationFilter)
class TanImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::TanImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_TanImageFilter

    def __init__(self):
        r"""__init__(TanImageFilter self) -> TanImageFilter"""
        _SimpleITK.TanImageFilter_swiginit(self, _SimpleITK.new_TanImageFilter())

    def GetName(self):
        r"""GetName(TanImageFilter self) -> std::string"""
        return _SimpleITK.TanImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(TanImageFilter self) -> std::string"""
        return _SimpleITK.TanImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(TanImageFilter self, Image image1) -> Image"""
        return _SimpleITK.TanImageFilter_Execute(self, image1)

# Register TanImageFilter in _SimpleITK:
_SimpleITK.TanImageFilter_swigregister(TanImageFilter)

def Tan(image1):
    r"""Tan(Image image1) -> Image"""
    return _SimpleITK.Tan(image1)
class TernaryAddImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::TernaryAddImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_TernaryAddImageFilter

    def __init__(self):
        r"""__init__(TernaryAddImageFilter self) -> TernaryAddImageFilter"""
        _SimpleITK.TernaryAddImageFilter_swiginit(self, _SimpleITK.new_TernaryAddImageFilter())

    def GetName(self):
        r"""GetName(TernaryAddImageFilter self) -> std::string"""
        return _SimpleITK.TernaryAddImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(TernaryAddImageFilter self) -> std::string"""
        return _SimpleITK.TernaryAddImageFilter___str__(self)

    def Execute(self, image1, image2, image3):
        r"""Execute(TernaryAddImageFilter self, Image image1, Image image2, Image image3) -> Image"""
        return _SimpleITK.TernaryAddImageFilter_Execute(self, image1, image2, image3)

# Register TernaryAddImageFilter in _SimpleITK:
_SimpleITK.TernaryAddImageFilter_swigregister(TernaryAddImageFilter)

def TernaryAdd(image1, image2, image3):
    r"""TernaryAdd(Image image1, Image image2, Image image3) -> Image"""
    return _SimpleITK.TernaryAdd(image1, image2, image3)
class TernaryMagnitudeImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::TernaryMagnitudeImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_TernaryMagnitudeImageFilter

    def __init__(self):
        r"""__init__(TernaryMagnitudeImageFilter self) -> TernaryMagnitudeImageFilter"""
        _SimpleITK.TernaryMagnitudeImageFilter_swiginit(self, _SimpleITK.new_TernaryMagnitudeImageFilter())

    def GetName(self):
        r"""GetName(TernaryMagnitudeImageFilter self) -> std::string"""
        return _SimpleITK.TernaryMagnitudeImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(TernaryMagnitudeImageFilter self) -> std::string"""
        return _SimpleITK.TernaryMagnitudeImageFilter___str__(self)

    def Execute(self, image1, image2, image3):
        r"""Execute(TernaryMagnitudeImageFilter self, Image image1, Image image2, Image image3) -> Image"""
        return _SimpleITK.TernaryMagnitudeImageFilter_Execute(self, image1, image2, image3)

# Register TernaryMagnitudeImageFilter in _SimpleITK:
_SimpleITK.TernaryMagnitudeImageFilter_swigregister(TernaryMagnitudeImageFilter)

def TernaryMagnitude(image1, image2, image3):
    r"""TernaryMagnitude(Image image1, Image image2, Image image3) -> Image"""
    return _SimpleITK.TernaryMagnitude(image1, image2, image3)
class TernaryMagnitudeSquaredImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::TernaryMagnitudeSquaredImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_TernaryMagnitudeSquaredImageFilter

    def __init__(self):
        r"""__init__(TernaryMagnitudeSquaredImageFilter self) -> TernaryMagnitudeSquaredImageFilter"""
        _SimpleITK.TernaryMagnitudeSquaredImageFilter_swiginit(self, _SimpleITK.new_TernaryMagnitudeSquaredImageFilter())

    def GetName(self):
        r"""GetName(TernaryMagnitudeSquaredImageFilter self) -> std::string"""
        return _SimpleITK.TernaryMagnitudeSquaredImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(TernaryMagnitudeSquaredImageFilter self) -> std::string"""
        return _SimpleITK.TernaryMagnitudeSquaredImageFilter___str__(self)

    def Execute(self, image1, image2, image3):
        r"""Execute(TernaryMagnitudeSquaredImageFilter self, Image image1, Image image2, Image image3) -> Image"""
        return _SimpleITK.TernaryMagnitudeSquaredImageFilter_Execute(self, image1, image2, image3)

# Register TernaryMagnitudeSquaredImageFilter in _SimpleITK:
_SimpleITK.TernaryMagnitudeSquaredImageFilter_swigregister(TernaryMagnitudeSquaredImageFilter)

def TernaryMagnitudeSquared(image1, image2, image3):
    r"""TernaryMagnitudeSquared(Image image1, Image image2, Image image3) -> Image"""
    return _SimpleITK.TernaryMagnitudeSquared(image1, image2, image3)
class ThresholdImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ThresholdImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ThresholdImageFilter

    def __init__(self):
        r"""__init__(ThresholdImageFilter self) -> ThresholdImageFilter"""
        _SimpleITK.ThresholdImageFilter_swiginit(self, _SimpleITK.new_ThresholdImageFilter())

    def SetLower(self, Lower):
        r"""SetLower(ThresholdImageFilter self, double Lower)"""
        return _SimpleITK.ThresholdImageFilter_SetLower(self, Lower)

    def GetLower(self):
        r"""GetLower(ThresholdImageFilter self) -> double"""
        return _SimpleITK.ThresholdImageFilter_GetLower(self)

    def SetUpper(self, Upper):
        r"""SetUpper(ThresholdImageFilter self, double Upper)"""
        return _SimpleITK.ThresholdImageFilter_SetUpper(self, Upper)

    def GetUpper(self):
        r"""GetUpper(ThresholdImageFilter self) -> double"""
        return _SimpleITK.ThresholdImageFilter_GetUpper(self)

    def SetOutsideValue(self, OutsideValue):
        r"""SetOutsideValue(ThresholdImageFilter self, double OutsideValue)"""
        return _SimpleITK.ThresholdImageFilter_SetOutsideValue(self, OutsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(ThresholdImageFilter self) -> double"""
        return _SimpleITK.ThresholdImageFilter_GetOutsideValue(self)

    def GetName(self):
        r"""GetName(ThresholdImageFilter self) -> std::string"""
        return _SimpleITK.ThresholdImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ThresholdImageFilter self) -> std::string"""
        return _SimpleITK.ThresholdImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ThresholdImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ThresholdImageFilter_Execute(self, image1)

    def ThresholdAbove(self, threshold):
        r"""ThresholdAbove(ThresholdImageFilter self, double threshold)"""
        return _SimpleITK.ThresholdImageFilter_ThresholdAbove(self, threshold)

    def ThresholdBelow(self, threshold):
        r"""ThresholdBelow(ThresholdImageFilter self, double threshold)"""
        return _SimpleITK.ThresholdImageFilter_ThresholdBelow(self, threshold)

    def ThresholdOutside(self, lower, upper):
        r"""ThresholdOutside(ThresholdImageFilter self, double lower, double upper)"""
        return _SimpleITK.ThresholdImageFilter_ThresholdOutside(self, lower, upper)

# Register ThresholdImageFilter in _SimpleITK:
_SimpleITK.ThresholdImageFilter_swigregister(ThresholdImageFilter)

def Threshold(image1, lower=0.0, upper=1.0, outsideValue=0.0):
    r"""Threshold(Image image1, double lower=0.0, double upper=1.0, double outsideValue=0.0) -> Image"""
    return _SimpleITK.Threshold(image1, lower, upper, outsideValue)
class ThresholdMaximumConnectedComponentsImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ThresholdMaximumConnectedComponentsImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ThresholdMaximumConnectedComponentsImageFilter

    def __init__(self):
        r"""__init__(ThresholdMaximumConnectedComponentsImageFilter self) -> ThresholdMaximumConnectedComponentsImageFilter"""
        _SimpleITK.ThresholdMaximumConnectedComponentsImageFilter_swiginit(self, _SimpleITK.new_ThresholdMaximumConnectedComponentsImageFilter())

    def SetMinimumObjectSizeInPixels(self, MinimumObjectSizeInPixels):
        r"""SetMinimumObjectSizeInPixels(ThresholdMaximumConnectedComponentsImageFilter self, uint32_t MinimumObjectSizeInPixels)"""
        return _SimpleITK.ThresholdMaximumConnectedComponentsImageFilter_SetMinimumObjectSizeInPixels(self, MinimumObjectSizeInPixels)

    def GetMinimumObjectSizeInPixels(self):
        r"""GetMinimumObjectSizeInPixels(ThresholdMaximumConnectedComponentsImageFilter self) -> uint32_t"""
        return _SimpleITK.ThresholdMaximumConnectedComponentsImageFilter_GetMinimumObjectSizeInPixels(self)

    def SetUpperBoundary(self, UpperBoundary):
        r"""SetUpperBoundary(ThresholdMaximumConnectedComponentsImageFilter self, double UpperBoundary)"""
        return _SimpleITK.ThresholdMaximumConnectedComponentsImageFilter_SetUpperBoundary(self, UpperBoundary)

    def GetUpperBoundary(self):
        r"""GetUpperBoundary(ThresholdMaximumConnectedComponentsImageFilter self) -> double"""
        return _SimpleITK.ThresholdMaximumConnectedComponentsImageFilter_GetUpperBoundary(self)

    def SetInsideValue(self, InsideValue):
        r"""SetInsideValue(ThresholdMaximumConnectedComponentsImageFilter self, uint8_t InsideValue)"""
        return _SimpleITK.ThresholdMaximumConnectedComponentsImageFilter_SetInsideValue(self, InsideValue)

    def GetInsideValue(self):
        r"""GetInsideValue(ThresholdMaximumConnectedComponentsImageFilter self) -> uint8_t"""
        return _SimpleITK.ThresholdMaximumConnectedComponentsImageFilter_GetInsideValue(self)

    def SetOutsideValue(self, OutsideValue):
        r"""SetOutsideValue(ThresholdMaximumConnectedComponentsImageFilter self, uint8_t OutsideValue)"""
        return _SimpleITK.ThresholdMaximumConnectedComponentsImageFilter_SetOutsideValue(self, OutsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(ThresholdMaximumConnectedComponentsImageFilter self) -> uint8_t"""
        return _SimpleITK.ThresholdMaximumConnectedComponentsImageFilter_GetOutsideValue(self)

    def GetName(self):
        r"""GetName(ThresholdMaximumConnectedComponentsImageFilter self) -> std::string"""
        return _SimpleITK.ThresholdMaximumConnectedComponentsImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ThresholdMaximumConnectedComponentsImageFilter self) -> std::string"""
        return _SimpleITK.ThresholdMaximumConnectedComponentsImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ThresholdMaximumConnectedComponentsImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ThresholdMaximumConnectedComponentsImageFilter_Execute(self, image1)

# Register ThresholdMaximumConnectedComponentsImageFilter in _SimpleITK:
_SimpleITK.ThresholdMaximumConnectedComponentsImageFilter_swigregister(ThresholdMaximumConnectedComponentsImageFilter)

def ThresholdMaximumConnectedComponents(*args, **kwargs):
    r"""ThresholdMaximumConnectedComponents(Image image1, uint32_t minimumObjectSizeInPixels=0, double upperBoundary=std::numeric_limits< double >::max(), uint8_t insideValue=1, uint8_t outsideValue=0) -> Image"""
    return _SimpleITK.ThresholdMaximumConnectedComponents(*args, **kwargs)
class ThresholdSegmentationLevelSetImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ThresholdSegmentationLevelSetImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ThresholdSegmentationLevelSetImageFilter

    def __init__(self):
        r"""__init__(ThresholdSegmentationLevelSetImageFilter self) -> ThresholdSegmentationLevelSetImageFilter"""
        _SimpleITK.ThresholdSegmentationLevelSetImageFilter_swiginit(self, _SimpleITK.new_ThresholdSegmentationLevelSetImageFilter())

    def SetLowerThreshold(self, LowerThreshold):
        r"""SetLowerThreshold(ThresholdSegmentationLevelSetImageFilter self, double LowerThreshold)"""
        return _SimpleITK.ThresholdSegmentationLevelSetImageFilter_SetLowerThreshold(self, LowerThreshold)

    def GetLowerThreshold(self):
        r"""GetLowerThreshold(ThresholdSegmentationLevelSetImageFilter self) -> double"""
        return _SimpleITK.ThresholdSegmentationLevelSetImageFilter_GetLowerThreshold(self)

    def SetUpperThreshold(self, UpperThreshold):
        r"""SetUpperThreshold(ThresholdSegmentationLevelSetImageFilter self, double UpperThreshold)"""
        return _SimpleITK.ThresholdSegmentationLevelSetImageFilter_SetUpperThreshold(self, UpperThreshold)

    def GetUpperThreshold(self):
        r"""GetUpperThreshold(ThresholdSegmentationLevelSetImageFilter self) -> double"""
        return _SimpleITK.ThresholdSegmentationLevelSetImageFilter_GetUpperThreshold(self)

    def SetMaximumRMSError(self, MaximumRMSError):
        r"""SetMaximumRMSError(ThresholdSegmentationLevelSetImageFilter self, double MaximumRMSError)"""
        return _SimpleITK.ThresholdSegmentationLevelSetImageFilter_SetMaximumRMSError(self, MaximumRMSError)

    def GetMaximumRMSError(self):
        r"""GetMaximumRMSError(ThresholdSegmentationLevelSetImageFilter self) -> double"""
        return _SimpleITK.ThresholdSegmentationLevelSetImageFilter_GetMaximumRMSError(self)

    def SetPropagationScaling(self, PropagationScaling):
        r"""SetPropagationScaling(ThresholdSegmentationLevelSetImageFilter self, double PropagationScaling)"""
        return _SimpleITK.ThresholdSegmentationLevelSetImageFilter_SetPropagationScaling(self, PropagationScaling)

    def GetPropagationScaling(self):
        r"""GetPropagationScaling(ThresholdSegmentationLevelSetImageFilter self) -> double"""
        return _SimpleITK.ThresholdSegmentationLevelSetImageFilter_GetPropagationScaling(self)

    def SetCurvatureScaling(self, CurvatureScaling):
        r"""SetCurvatureScaling(ThresholdSegmentationLevelSetImageFilter self, double CurvatureScaling)"""
        return _SimpleITK.ThresholdSegmentationLevelSetImageFilter_SetCurvatureScaling(self, CurvatureScaling)

    def GetCurvatureScaling(self):
        r"""GetCurvatureScaling(ThresholdSegmentationLevelSetImageFilter self) -> double"""
        return _SimpleITK.ThresholdSegmentationLevelSetImageFilter_GetCurvatureScaling(self)

    def SetNumberOfIterations(self, NumberOfIterations):
        r"""SetNumberOfIterations(ThresholdSegmentationLevelSetImageFilter self, uint32_t NumberOfIterations)"""
        return _SimpleITK.ThresholdSegmentationLevelSetImageFilter_SetNumberOfIterations(self, NumberOfIterations)

    def GetNumberOfIterations(self):
        r"""GetNumberOfIterations(ThresholdSegmentationLevelSetImageFilter self) -> uint32_t"""
        return _SimpleITK.ThresholdSegmentationLevelSetImageFilter_GetNumberOfIterations(self)

    def SetReverseExpansionDirection(self, ReverseExpansionDirection):
        r"""SetReverseExpansionDirection(ThresholdSegmentationLevelSetImageFilter self, bool ReverseExpansionDirection)"""
        return _SimpleITK.ThresholdSegmentationLevelSetImageFilter_SetReverseExpansionDirection(self, ReverseExpansionDirection)

    def ReverseExpansionDirectionOn(self):
        r"""ReverseExpansionDirectionOn(ThresholdSegmentationLevelSetImageFilter self)"""
        return _SimpleITK.ThresholdSegmentationLevelSetImageFilter_ReverseExpansionDirectionOn(self)

    def ReverseExpansionDirectionOff(self):
        r"""ReverseExpansionDirectionOff(ThresholdSegmentationLevelSetImageFilter self)"""
        return _SimpleITK.ThresholdSegmentationLevelSetImageFilter_ReverseExpansionDirectionOff(self)

    def GetReverseExpansionDirection(self):
        r"""GetReverseExpansionDirection(ThresholdSegmentationLevelSetImageFilter self) -> bool"""
        return _SimpleITK.ThresholdSegmentationLevelSetImageFilter_GetReverseExpansionDirection(self)

    def GetElapsedIterations(self):
        r"""GetElapsedIterations(ThresholdSegmentationLevelSetImageFilter self) -> uint32_t"""
        return _SimpleITK.ThresholdSegmentationLevelSetImageFilter_GetElapsedIterations(self)

    def GetRMSChange(self):
        r"""GetRMSChange(ThresholdSegmentationLevelSetImageFilter self) -> double"""
        return _SimpleITK.ThresholdSegmentationLevelSetImageFilter_GetRMSChange(self)

    def GetName(self):
        r"""GetName(ThresholdSegmentationLevelSetImageFilter self) -> std::string"""
        return _SimpleITK.ThresholdSegmentationLevelSetImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ThresholdSegmentationLevelSetImageFilter self) -> std::string"""
        return _SimpleITK.ThresholdSegmentationLevelSetImageFilter___str__(self)

    def Execute(self, initialImage, featureImage):
        r"""Execute(ThresholdSegmentationLevelSetImageFilter self, Image initialImage, Image featureImage) -> Image"""
        return _SimpleITK.ThresholdSegmentationLevelSetImageFilter_Execute(self, initialImage, featureImage)

# Register ThresholdSegmentationLevelSetImageFilter in _SimpleITK:
_SimpleITK.ThresholdSegmentationLevelSetImageFilter_swigregister(ThresholdSegmentationLevelSetImageFilter)

def ThresholdSegmentationLevelSet(initialImage, featureImage, lowerThreshold=0.0, upperThreshold=255.0, maximumRMSError=0.02, propagationScaling=1.0, curvatureScaling=1.0, numberOfIterations=1000, reverseExpansionDirection=False):
    r"""ThresholdSegmentationLevelSet(Image initialImage, Image featureImage, double lowerThreshold=0.0, double upperThreshold=255.0, double maximumRMSError=0.02, double propagationScaling=1.0, double curvatureScaling=1.0, uint32_t numberOfIterations=1000, bool reverseExpansionDirection=False) -> Image"""
    return _SimpleITK.ThresholdSegmentationLevelSet(initialImage, featureImage, lowerThreshold, upperThreshold, maximumRMSError, propagationScaling, curvatureScaling, numberOfIterations, reverseExpansionDirection)
class TikhonovDeconvolutionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::TikhonovDeconvolutionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_TikhonovDeconvolutionImageFilter

    def __init__(self):
        r"""__init__(TikhonovDeconvolutionImageFilter self) -> TikhonovDeconvolutionImageFilter"""
        _SimpleITK.TikhonovDeconvolutionImageFilter_swiginit(self, _SimpleITK.new_TikhonovDeconvolutionImageFilter())

    def SetRegularizationConstant(self, RegularizationConstant):
        r"""SetRegularizationConstant(TikhonovDeconvolutionImageFilter self, double RegularizationConstant)"""
        return _SimpleITK.TikhonovDeconvolutionImageFilter_SetRegularizationConstant(self, RegularizationConstant)

    def GetRegularizationConstant(self):
        r"""GetRegularizationConstant(TikhonovDeconvolutionImageFilter self) -> double"""
        return _SimpleITK.TikhonovDeconvolutionImageFilter_GetRegularizationConstant(self)

    def SetNormalize(self, Normalize):
        r"""SetNormalize(TikhonovDeconvolutionImageFilter self, bool Normalize)"""
        return _SimpleITK.TikhonovDeconvolutionImageFilter_SetNormalize(self, Normalize)

    def NormalizeOn(self):
        r"""NormalizeOn(TikhonovDeconvolutionImageFilter self)"""
        return _SimpleITK.TikhonovDeconvolutionImageFilter_NormalizeOn(self)

    def NormalizeOff(self):
        r"""NormalizeOff(TikhonovDeconvolutionImageFilter self)"""
        return _SimpleITK.TikhonovDeconvolutionImageFilter_NormalizeOff(self)

    def GetNormalize(self):
        r"""GetNormalize(TikhonovDeconvolutionImageFilter self) -> bool"""
        return _SimpleITK.TikhonovDeconvolutionImageFilter_GetNormalize(self)
    ZERO_PAD = _SimpleITK.TikhonovDeconvolutionImageFilter_ZERO_PAD
    
    ZERO_FLUX_NEUMANN_PAD = _SimpleITK.TikhonovDeconvolutionImageFilter_ZERO_FLUX_NEUMANN_PAD
    
    PERIODIC_PAD = _SimpleITK.TikhonovDeconvolutionImageFilter_PERIODIC_PAD
    

    def SetBoundaryCondition(self, BoundaryCondition):
        r"""SetBoundaryCondition(TikhonovDeconvolutionImageFilter self, slicer_itk::simple::TikhonovDeconvolutionImageFilter::BoundaryConditionType BoundaryCondition)"""
        return _SimpleITK.TikhonovDeconvolutionImageFilter_SetBoundaryCondition(self, BoundaryCondition)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(TikhonovDeconvolutionImageFilter self) -> slicer_itk::simple::TikhonovDeconvolutionImageFilter::BoundaryConditionType"""
        return _SimpleITK.TikhonovDeconvolutionImageFilter_GetBoundaryCondition(self)
    SAME = _SimpleITK.TikhonovDeconvolutionImageFilter_SAME
    
    VALID = _SimpleITK.TikhonovDeconvolutionImageFilter_VALID
    

    def SetOutputRegionMode(self, OutputRegionMode):
        r"""SetOutputRegionMode(TikhonovDeconvolutionImageFilter self, slicer_itk::simple::TikhonovDeconvolutionImageFilter::OutputRegionModeType OutputRegionMode)"""
        return _SimpleITK.TikhonovDeconvolutionImageFilter_SetOutputRegionMode(self, OutputRegionMode)

    def GetOutputRegionMode(self):
        r"""GetOutputRegionMode(TikhonovDeconvolutionImageFilter self) -> slicer_itk::simple::TikhonovDeconvolutionImageFilter::OutputRegionModeType"""
        return _SimpleITK.TikhonovDeconvolutionImageFilter_GetOutputRegionMode(self)

    def GetName(self):
        r"""GetName(TikhonovDeconvolutionImageFilter self) -> std::string"""
        return _SimpleITK.TikhonovDeconvolutionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(TikhonovDeconvolutionImageFilter self) -> std::string"""
        return _SimpleITK.TikhonovDeconvolutionImageFilter___str__(self)

    def Execute(self, image1, image2):
        r"""Execute(TikhonovDeconvolutionImageFilter self, Image image1, Image image2) -> Image"""
        return _SimpleITK.TikhonovDeconvolutionImageFilter_Execute(self, image1, image2)

# Register TikhonovDeconvolutionImageFilter in _SimpleITK:
_SimpleITK.TikhonovDeconvolutionImageFilter_swigregister(TikhonovDeconvolutionImageFilter)

def TikhonovDeconvolution(*args, **kwargs):
    r"""TikhonovDeconvolution(Image image1, Image image2, double regularizationConstant=0.0, bool normalize=False, slicer_itk::simple::TikhonovDeconvolutionImageFilter::BoundaryConditionType boundaryCondition=ZERO_FLUX_NEUMANN_PAD, slicer_itk::simple::TikhonovDeconvolutionImageFilter::OutputRegionModeType outputRegionMode=SAME) -> Image"""
    return _SimpleITK.TikhonovDeconvolution(*args, **kwargs)
class TileImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::TileImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_TileImageFilter

    def __init__(self):
        r"""__init__(TileImageFilter self) -> TileImageFilter"""
        _SimpleITK.TileImageFilter_swiginit(self, _SimpleITK.new_TileImageFilter())

    def SetLayout(self, Layout):
        r"""SetLayout(TileImageFilter self, VectorUInt32 Layout)"""
        return _SimpleITK.TileImageFilter_SetLayout(self, Layout)

    def GetLayout(self):
        r"""GetLayout(TileImageFilter self) -> VectorUInt32"""
        return _SimpleITK.TileImageFilter_GetLayout(self)

    def SetDefaultPixelValue(self, DefaultPixelValue):
        r"""SetDefaultPixelValue(TileImageFilter self, double DefaultPixelValue)"""
        return _SimpleITK.TileImageFilter_SetDefaultPixelValue(self, DefaultPixelValue)

    def GetDefaultPixelValue(self):
        r"""GetDefaultPixelValue(TileImageFilter self) -> double"""
        return _SimpleITK.TileImageFilter_GetDefaultPixelValue(self)

    def GetName(self):
        r"""GetName(TileImageFilter self) -> std::string"""
        return _SimpleITK.TileImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(TileImageFilter self) -> std::string"""
        return _SimpleITK.TileImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(TileImageFilter self, VectorOfImage images) -> Image
        Execute(TileImageFilter self, Image image1) -> Image
        Execute(TileImageFilter self, Image image1, Image image2) -> Image
        Execute(TileImageFilter self, Image image1, Image image2, Image image3) -> Image
        Execute(TileImageFilter self, Image image1, Image image2, Image image3, Image image4) -> Image
        Execute(TileImageFilter self, Image image1, Image image2, Image image3, Image image4, Image image5) -> Image
        """
        return _SimpleITK.TileImageFilter_Execute(self, *args)

# Register TileImageFilter in _SimpleITK:
_SimpleITK.TileImageFilter_swigregister(TileImageFilter)

def Tile(*args):
    r"""
    Tile(VectorOfImage images, VectorUInt32 layout=std::vector< uint32_t >(3, 100), double defaultPixelValue=0.0) -> Image
    Tile(Image image1, VectorUInt32 layout=std::vector< uint32_t >(3, 100), double defaultPixelValue=0.0) -> Image
    Tile(Image image1, Image image2, VectorUInt32 layout=std::vector< uint32_t >(3, 100), double defaultPixelValue=0.0) -> Image
    Tile(Image image1, Image image2, Image image3, VectorUInt32 layout=std::vector< uint32_t >(3, 100), double defaultPixelValue=0.0) -> Image
    Tile(Image image1, Image image2, Image image3, Image image4, VectorUInt32 layout=std::vector< uint32_t >(3, 100), double defaultPixelValue=0.0) -> Image
    Tile(Image image1, Image image2, Image image3, Image image4, Image image5, VectorUInt32 layout=std::vector< uint32_t >(3, 100), double defaultPixelValue=0.0) -> Image
    """
    return _SimpleITK.Tile(*args)
class TobogganImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::TobogganImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_TobogganImageFilter

    def __init__(self):
        r"""__init__(TobogganImageFilter self) -> TobogganImageFilter"""
        _SimpleITK.TobogganImageFilter_swiginit(self, _SimpleITK.new_TobogganImageFilter())

    def GetName(self):
        r"""GetName(TobogganImageFilter self) -> std::string"""
        return _SimpleITK.TobogganImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(TobogganImageFilter self) -> std::string"""
        return _SimpleITK.TobogganImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(TobogganImageFilter self, Image image1) -> Image"""
        return _SimpleITK.TobogganImageFilter_Execute(self, image1)

# Register TobogganImageFilter in _SimpleITK:
_SimpleITK.TobogganImageFilter_swigregister(TobogganImageFilter)

def Toboggan(image1):
    r"""Toboggan(Image image1) -> Image"""
    return _SimpleITK.Toboggan(image1)
class TransformGeometryImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::TransformGeometryImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_TransformGeometryImageFilter

    def __init__(self):
        r"""__init__(TransformGeometryImageFilter self) -> TransformGeometryImageFilter"""
        _SimpleITK.TransformGeometryImageFilter_swiginit(self, _SimpleITK.new_TransformGeometryImageFilter())

    def GetName(self):
        r"""GetName(TransformGeometryImageFilter self) -> std::string"""
        return _SimpleITK.TransformGeometryImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(TransformGeometryImageFilter self) -> std::string"""
        return _SimpleITK.TransformGeometryImageFilter___str__(self)

    def Execute(self, image, transform):
        r"""Execute(TransformGeometryImageFilter self, Image image, Transform transform) -> Image"""
        return _SimpleITK.TransformGeometryImageFilter_Execute(self, image, transform)

# Register TransformGeometryImageFilter in _SimpleITK:
_SimpleITK.TransformGeometryImageFilter_swigregister(TransformGeometryImageFilter)

def TransformGeometry(image, transform):
    r"""TransformGeometry(Image image, Transform transform) -> Image"""
    return _SimpleITK.TransformGeometry(image, transform)
class TransformToDisplacementFieldFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::TransformToDisplacementFieldFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_TransformToDisplacementFieldFilter

    def __init__(self):
        r"""__init__(TransformToDisplacementFieldFilter self) -> TransformToDisplacementFieldFilter"""
        _SimpleITK.TransformToDisplacementFieldFilter_swiginit(self, _SimpleITK.new_TransformToDisplacementFieldFilter())

    def SetOutputPixelType(self, OutputPixelType):
        r"""SetOutputPixelType(TransformToDisplacementFieldFilter self, slicer_itk::simple::PixelIDValueEnum OutputPixelType)"""
        return _SimpleITK.TransformToDisplacementFieldFilter_SetOutputPixelType(self, OutputPixelType)

    def GetOutputPixelType(self):
        r"""GetOutputPixelType(TransformToDisplacementFieldFilter self) -> slicer_itk::simple::PixelIDValueEnum"""
        return _SimpleITK.TransformToDisplacementFieldFilter_GetOutputPixelType(self)

    def SetSize(self, Size):
        r"""SetSize(TransformToDisplacementFieldFilter self, VectorUInt32 Size)"""
        return _SimpleITK.TransformToDisplacementFieldFilter_SetSize(self, Size)

    def GetSize(self):
        r"""GetSize(TransformToDisplacementFieldFilter self) -> VectorUInt32"""
        return _SimpleITK.TransformToDisplacementFieldFilter_GetSize(self)

    def SetOutputOrigin(self, OutputOrigin):
        r"""SetOutputOrigin(TransformToDisplacementFieldFilter self, VectorDouble OutputOrigin)"""
        return _SimpleITK.TransformToDisplacementFieldFilter_SetOutputOrigin(self, OutputOrigin)

    def GetOutputOrigin(self):
        r"""GetOutputOrigin(TransformToDisplacementFieldFilter self) -> VectorDouble"""
        return _SimpleITK.TransformToDisplacementFieldFilter_GetOutputOrigin(self)

    def SetOutputSpacing(self, OutputSpacing):
        r"""SetOutputSpacing(TransformToDisplacementFieldFilter self, VectorDouble OutputSpacing)"""
        return _SimpleITK.TransformToDisplacementFieldFilter_SetOutputSpacing(self, OutputSpacing)

    def GetOutputSpacing(self):
        r"""GetOutputSpacing(TransformToDisplacementFieldFilter self) -> VectorDouble"""
        return _SimpleITK.TransformToDisplacementFieldFilter_GetOutputSpacing(self)

    def SetOutputDirection(self, OutputDirection):
        r"""SetOutputDirection(TransformToDisplacementFieldFilter self, VectorDouble OutputDirection)"""
        return _SimpleITK.TransformToDisplacementFieldFilter_SetOutputDirection(self, OutputDirection)

    def GetOutputDirection(self):
        r"""GetOutputDirection(TransformToDisplacementFieldFilter self) -> VectorDouble"""
        return _SimpleITK.TransformToDisplacementFieldFilter_GetOutputDirection(self)

    def GetName(self):
        r"""GetName(TransformToDisplacementFieldFilter self) -> std::string"""
        return _SimpleITK.TransformToDisplacementFieldFilter_GetName(self)

    def __str__(self):
        r"""__str__(TransformToDisplacementFieldFilter self) -> std::string"""
        return _SimpleITK.TransformToDisplacementFieldFilter___str__(self)

    def Execute(self, transform):
        r"""Execute(TransformToDisplacementFieldFilter self, Transform transform) -> Image"""
        return _SimpleITK.TransformToDisplacementFieldFilter_Execute(self, transform)

    def SetReferenceImage(self, refImage):
        r"""SetReferenceImage(TransformToDisplacementFieldFilter self, Image refImage)"""
        return _SimpleITK.TransformToDisplacementFieldFilter_SetReferenceImage(self, refImage)

# Register TransformToDisplacementFieldFilter in _SimpleITK:
_SimpleITK.TransformToDisplacementFieldFilter_swigregister(TransformToDisplacementFieldFilter)

def TransformToDisplacementField(*args, **kwargs):
    r"""TransformToDisplacementField(Transform transform, slicer_itk::simple::PixelIDValueEnum outputPixelType=sitkVectorFloat64, VectorUInt32 size=std::vector< unsigned int >(3, 64), VectorDouble outputOrigin=std::vector< double >(3, 0.0), VectorDouble outputSpacing=std::vector< double >(3, 1.0), VectorDouble outputDirection=std::vector< double >()) -> Image"""
    return _SimpleITK.TransformToDisplacementField(*args, **kwargs)
class TriangleThresholdImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::TriangleThresholdImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_TriangleThresholdImageFilter

    def __init__(self):
        r"""__init__(TriangleThresholdImageFilter self) -> TriangleThresholdImageFilter"""
        _SimpleITK.TriangleThresholdImageFilter_swiginit(self, _SimpleITK.new_TriangleThresholdImageFilter())

    def SetInsideValue(self, InsideValue):
        r"""SetInsideValue(TriangleThresholdImageFilter self, uint8_t InsideValue)"""
        return _SimpleITK.TriangleThresholdImageFilter_SetInsideValue(self, InsideValue)

    def GetInsideValue(self):
        r"""GetInsideValue(TriangleThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.TriangleThresholdImageFilter_GetInsideValue(self)

    def SetOutsideValue(self, OutsideValue):
        r"""SetOutsideValue(TriangleThresholdImageFilter self, uint8_t OutsideValue)"""
        return _SimpleITK.TriangleThresholdImageFilter_SetOutsideValue(self, OutsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(TriangleThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.TriangleThresholdImageFilter_GetOutsideValue(self)

    def SetNumberOfHistogramBins(self, NumberOfHistogramBins):
        r"""SetNumberOfHistogramBins(TriangleThresholdImageFilter self, uint32_t NumberOfHistogramBins)"""
        return _SimpleITK.TriangleThresholdImageFilter_SetNumberOfHistogramBins(self, NumberOfHistogramBins)

    def GetNumberOfHistogramBins(self):
        r"""GetNumberOfHistogramBins(TriangleThresholdImageFilter self) -> uint32_t"""
        return _SimpleITK.TriangleThresholdImageFilter_GetNumberOfHistogramBins(self)

    def SetMaskOutput(self, MaskOutput):
        r"""SetMaskOutput(TriangleThresholdImageFilter self, bool MaskOutput)"""
        return _SimpleITK.TriangleThresholdImageFilter_SetMaskOutput(self, MaskOutput)

    def MaskOutputOn(self):
        r"""MaskOutputOn(TriangleThresholdImageFilter self)"""
        return _SimpleITK.TriangleThresholdImageFilter_MaskOutputOn(self)

    def MaskOutputOff(self):
        r"""MaskOutputOff(TriangleThresholdImageFilter self)"""
        return _SimpleITK.TriangleThresholdImageFilter_MaskOutputOff(self)

    def GetMaskOutput(self):
        r"""GetMaskOutput(TriangleThresholdImageFilter self) -> bool"""
        return _SimpleITK.TriangleThresholdImageFilter_GetMaskOutput(self)

    def SetMaskValue(self, MaskValue):
        r"""SetMaskValue(TriangleThresholdImageFilter self, uint8_t MaskValue)"""
        return _SimpleITK.TriangleThresholdImageFilter_SetMaskValue(self, MaskValue)

    def GetMaskValue(self):
        r"""GetMaskValue(TriangleThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.TriangleThresholdImageFilter_GetMaskValue(self)

    def GetThreshold(self):
        r"""GetThreshold(TriangleThresholdImageFilter self) -> double"""
        return _SimpleITK.TriangleThresholdImageFilter_GetThreshold(self)

    def GetName(self):
        r"""GetName(TriangleThresholdImageFilter self) -> std::string"""
        return _SimpleITK.TriangleThresholdImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(TriangleThresholdImageFilter self) -> std::string"""
        return _SimpleITK.TriangleThresholdImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(TriangleThresholdImageFilter self, Image image, Image maskImage) -> Image
        Execute(TriangleThresholdImageFilter self, Image image) -> Image
        """
        return _SimpleITK.TriangleThresholdImageFilter_Execute(self, *args)

# Register TriangleThresholdImageFilter in _SimpleITK:
_SimpleITK.TriangleThresholdImageFilter_swigregister(TriangleThresholdImageFilter)

def TriangleThreshold(*args):
    r"""
    TriangleThreshold(Image image, Image maskImage, uint8_t insideValue=1, uint8_t outsideValue=0, uint32_t numberOfHistogramBins=256, bool maskOutput=True, uint8_t maskValue=255) -> Image
    TriangleThreshold(Image image, uint8_t insideValue=1, uint8_t outsideValue=0, uint32_t numberOfHistogramBins=256, bool maskOutput=True, uint8_t maskValue=255) -> Image
    """
    return _SimpleITK.TriangleThreshold(*args)
class UnaryMinusImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::UnaryMinusImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_UnaryMinusImageFilter

    def __init__(self):
        r"""__init__(UnaryMinusImageFilter self) -> UnaryMinusImageFilter"""
        _SimpleITK.UnaryMinusImageFilter_swiginit(self, _SimpleITK.new_UnaryMinusImageFilter())

    def GetName(self):
        r"""GetName(UnaryMinusImageFilter self) -> std::string"""
        return _SimpleITK.UnaryMinusImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(UnaryMinusImageFilter self) -> std::string"""
        return _SimpleITK.UnaryMinusImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(UnaryMinusImageFilter self, Image image1) -> Image"""
        return _SimpleITK.UnaryMinusImageFilter_Execute(self, image1)

# Register UnaryMinusImageFilter in _SimpleITK:
_SimpleITK.UnaryMinusImageFilter_swigregister(UnaryMinusImageFilter)

def UnaryMinus(image1):
    r"""UnaryMinus(Image image1) -> Image"""
    return _SimpleITK.UnaryMinus(image1)
class UnsharpMaskImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::UnsharpMaskImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_UnsharpMaskImageFilter

    def __init__(self):
        r"""__init__(UnsharpMaskImageFilter self) -> UnsharpMaskImageFilter"""
        _SimpleITK.UnsharpMaskImageFilter_swiginit(self, _SimpleITK.new_UnsharpMaskImageFilter())

    def SetSigmas(self, *args):
        r"""
        SetSigmas(UnsharpMaskImageFilter self, double s)
        SetSigmas(UnsharpMaskImageFilter self, VectorDouble Sigmas)
        """
        return _SimpleITK.UnsharpMaskImageFilter_SetSigmas(self, *args)

    def GetSigmas(self):
        r"""GetSigmas(UnsharpMaskImageFilter self) -> VectorDouble"""
        return _SimpleITK.UnsharpMaskImageFilter_GetSigmas(self)

    def SetAmount(self, Amount):
        r"""SetAmount(UnsharpMaskImageFilter self, double Amount)"""
        return _SimpleITK.UnsharpMaskImageFilter_SetAmount(self, Amount)

    def GetAmount(self):
        r"""GetAmount(UnsharpMaskImageFilter self) -> double"""
        return _SimpleITK.UnsharpMaskImageFilter_GetAmount(self)

    def SetThreshold(self, Threshold):
        r"""SetThreshold(UnsharpMaskImageFilter self, double Threshold)"""
        return _SimpleITK.UnsharpMaskImageFilter_SetThreshold(self, Threshold)

    def GetThreshold(self):
        r"""GetThreshold(UnsharpMaskImageFilter self) -> double"""
        return _SimpleITK.UnsharpMaskImageFilter_GetThreshold(self)

    def SetClamp(self, Clamp):
        r"""SetClamp(UnsharpMaskImageFilter self, bool Clamp)"""
        return _SimpleITK.UnsharpMaskImageFilter_SetClamp(self, Clamp)

    def ClampOn(self):
        r"""ClampOn(UnsharpMaskImageFilter self)"""
        return _SimpleITK.UnsharpMaskImageFilter_ClampOn(self)

    def ClampOff(self):
        r"""ClampOff(UnsharpMaskImageFilter self)"""
        return _SimpleITK.UnsharpMaskImageFilter_ClampOff(self)

    def GetClamp(self):
        r"""GetClamp(UnsharpMaskImageFilter self) -> bool"""
        return _SimpleITK.UnsharpMaskImageFilter_GetClamp(self)

    def GetName(self):
        r"""GetName(UnsharpMaskImageFilter self) -> std::string"""
        return _SimpleITK.UnsharpMaskImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(UnsharpMaskImageFilter self) -> std::string"""
        return _SimpleITK.UnsharpMaskImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(UnsharpMaskImageFilter self, Image image1) -> Image"""
        return _SimpleITK.UnsharpMaskImageFilter_Execute(self, image1)

# Register UnsharpMaskImageFilter in _SimpleITK:
_SimpleITK.UnsharpMaskImageFilter_swigregister(UnsharpMaskImageFilter)

def UnsharpMask(*args, **kwargs):
    r"""UnsharpMask(Image image1, VectorDouble sigmas=std::vector< double >(3, 1.0), double amount=0.5, double threshold=0.0, bool clamp=True) -> Image"""
    return _SimpleITK.UnsharpMask(*args, **kwargs)
class ValuedRegionalMaximaImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ValuedRegionalMaximaImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ValuedRegionalMaximaImageFilter

    def __init__(self):
        r"""__init__(ValuedRegionalMaximaImageFilter self) -> ValuedRegionalMaximaImageFilter"""
        _SimpleITK.ValuedRegionalMaximaImageFilter_swiginit(self, _SimpleITK.new_ValuedRegionalMaximaImageFilter())

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(ValuedRegionalMaximaImageFilter self, bool FullyConnected)"""
        return _SimpleITK.ValuedRegionalMaximaImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(ValuedRegionalMaximaImageFilter self)"""
        return _SimpleITK.ValuedRegionalMaximaImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(ValuedRegionalMaximaImageFilter self)"""
        return _SimpleITK.ValuedRegionalMaximaImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(ValuedRegionalMaximaImageFilter self) -> bool"""
        return _SimpleITK.ValuedRegionalMaximaImageFilter_GetFullyConnected(self)

    def GetFlat(self):
        r"""GetFlat(ValuedRegionalMaximaImageFilter self) -> bool"""
        return _SimpleITK.ValuedRegionalMaximaImageFilter_GetFlat(self)

    def GetName(self):
        r"""GetName(ValuedRegionalMaximaImageFilter self) -> std::string"""
        return _SimpleITK.ValuedRegionalMaximaImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ValuedRegionalMaximaImageFilter self) -> std::string"""
        return _SimpleITK.ValuedRegionalMaximaImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ValuedRegionalMaximaImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ValuedRegionalMaximaImageFilter_Execute(self, image1)

# Register ValuedRegionalMaximaImageFilter in _SimpleITK:
_SimpleITK.ValuedRegionalMaximaImageFilter_swigregister(ValuedRegionalMaximaImageFilter)

def ValuedRegionalMaxima(image1, fullyConnected=False):
    r"""ValuedRegionalMaxima(Image image1, bool fullyConnected=False) -> Image"""
    return _SimpleITK.ValuedRegionalMaxima(image1, fullyConnected)
class ValuedRegionalMinimaImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ValuedRegionalMinimaImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ValuedRegionalMinimaImageFilter

    def __init__(self):
        r"""__init__(ValuedRegionalMinimaImageFilter self) -> ValuedRegionalMinimaImageFilter"""
        _SimpleITK.ValuedRegionalMinimaImageFilter_swiginit(self, _SimpleITK.new_ValuedRegionalMinimaImageFilter())

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(ValuedRegionalMinimaImageFilter self, bool FullyConnected)"""
        return _SimpleITK.ValuedRegionalMinimaImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(ValuedRegionalMinimaImageFilter self)"""
        return _SimpleITK.ValuedRegionalMinimaImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(ValuedRegionalMinimaImageFilter self)"""
        return _SimpleITK.ValuedRegionalMinimaImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(ValuedRegionalMinimaImageFilter self) -> bool"""
        return _SimpleITK.ValuedRegionalMinimaImageFilter_GetFullyConnected(self)

    def GetFlat(self):
        r"""GetFlat(ValuedRegionalMinimaImageFilter self) -> bool"""
        return _SimpleITK.ValuedRegionalMinimaImageFilter_GetFlat(self)

    def GetName(self):
        r"""GetName(ValuedRegionalMinimaImageFilter self) -> std::string"""
        return _SimpleITK.ValuedRegionalMinimaImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ValuedRegionalMinimaImageFilter self) -> std::string"""
        return _SimpleITK.ValuedRegionalMinimaImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ValuedRegionalMinimaImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ValuedRegionalMinimaImageFilter_Execute(self, image1)

# Register ValuedRegionalMinimaImageFilter in _SimpleITK:
_SimpleITK.ValuedRegionalMinimaImageFilter_swigregister(ValuedRegionalMinimaImageFilter)

def ValuedRegionalMinima(image1, fullyConnected=False):
    r"""ValuedRegionalMinima(Image image1, bool fullyConnected=False) -> Image"""
    return _SimpleITK.ValuedRegionalMinima(image1, fullyConnected)
class VectorConfidenceConnectedImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::VectorConfidenceConnectedImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_VectorConfidenceConnectedImageFilter

    def __init__(self):
        r"""__init__(VectorConfidenceConnectedImageFilter self) -> VectorConfidenceConnectedImageFilter"""
        _SimpleITK.VectorConfidenceConnectedImageFilter_swiginit(self, _SimpleITK.new_VectorConfidenceConnectedImageFilter())

    def SetSeedList(self, SeedList):
        r"""SetSeedList(VectorConfidenceConnectedImageFilter self, VectorUIntList SeedList)"""
        return _SimpleITK.VectorConfidenceConnectedImageFilter_SetSeedList(self, SeedList)

    def GetSeedList(self):
        r"""GetSeedList(VectorConfidenceConnectedImageFilter self) -> VectorUIntList"""
        return _SimpleITK.VectorConfidenceConnectedImageFilter_GetSeedList(self)

    def AddSeed(self, point):
        r"""AddSeed(VectorConfidenceConnectedImageFilter self, VectorUInt32 point)"""
        return _SimpleITK.VectorConfidenceConnectedImageFilter_AddSeed(self, point)

    def ClearSeeds(self):
        r"""ClearSeeds(VectorConfidenceConnectedImageFilter self)"""
        return _SimpleITK.VectorConfidenceConnectedImageFilter_ClearSeeds(self)

    def SetNumberOfIterations(self, NumberOfIterations):
        r"""SetNumberOfIterations(VectorConfidenceConnectedImageFilter self, unsigned int NumberOfIterations)"""
        return _SimpleITK.VectorConfidenceConnectedImageFilter_SetNumberOfIterations(self, NumberOfIterations)

    def GetNumberOfIterations(self):
        r"""GetNumberOfIterations(VectorConfidenceConnectedImageFilter self) -> unsigned int"""
        return _SimpleITK.VectorConfidenceConnectedImageFilter_GetNumberOfIterations(self)

    def SetMultiplier(self, Multiplier):
        r"""SetMultiplier(VectorConfidenceConnectedImageFilter self, double Multiplier)"""
        return _SimpleITK.VectorConfidenceConnectedImageFilter_SetMultiplier(self, Multiplier)

    def GetMultiplier(self):
        r"""GetMultiplier(VectorConfidenceConnectedImageFilter self) -> double"""
        return _SimpleITK.VectorConfidenceConnectedImageFilter_GetMultiplier(self)

    def SetInitialNeighborhoodRadius(self, InitialNeighborhoodRadius):
        r"""SetInitialNeighborhoodRadius(VectorConfidenceConnectedImageFilter self, unsigned int InitialNeighborhoodRadius)"""
        return _SimpleITK.VectorConfidenceConnectedImageFilter_SetInitialNeighborhoodRadius(self, InitialNeighborhoodRadius)

    def GetInitialNeighborhoodRadius(self):
        r"""GetInitialNeighborhoodRadius(VectorConfidenceConnectedImageFilter self) -> unsigned int"""
        return _SimpleITK.VectorConfidenceConnectedImageFilter_GetInitialNeighborhoodRadius(self)

    def SetReplaceValue(self, ReplaceValue):
        r"""SetReplaceValue(VectorConfidenceConnectedImageFilter self, uint8_t ReplaceValue)"""
        return _SimpleITK.VectorConfidenceConnectedImageFilter_SetReplaceValue(self, ReplaceValue)

    def GetReplaceValue(self):
        r"""GetReplaceValue(VectorConfidenceConnectedImageFilter self) -> uint8_t"""
        return _SimpleITK.VectorConfidenceConnectedImageFilter_GetReplaceValue(self)

    def GetMean(self):
        r"""GetMean(VectorConfidenceConnectedImageFilter self) -> VectorDouble"""
        return _SimpleITK.VectorConfidenceConnectedImageFilter_GetMean(self)

    def GetCovariance(self):
        r"""GetCovariance(VectorConfidenceConnectedImageFilter self) -> VectorDouble"""
        return _SimpleITK.VectorConfidenceConnectedImageFilter_GetCovariance(self)

    def GetName(self):
        r"""GetName(VectorConfidenceConnectedImageFilter self) -> std::string"""
        return _SimpleITK.VectorConfidenceConnectedImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(VectorConfidenceConnectedImageFilter self) -> std::string"""
        return _SimpleITK.VectorConfidenceConnectedImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(VectorConfidenceConnectedImageFilter self, Image image1) -> Image"""
        return _SimpleITK.VectorConfidenceConnectedImageFilter_Execute(self, image1)

# Register VectorConfidenceConnectedImageFilter in _SimpleITK:
_SimpleITK.VectorConfidenceConnectedImageFilter_swigregister(VectorConfidenceConnectedImageFilter)

def VectorConfidenceConnected(*args, **kwargs):
    r"""VectorConfidenceConnected(Image image1, VectorUIntList seedList=std::vector< std::vector< unsigned int > >(), unsigned int numberOfIterations=4, double multiplier=4.5, unsigned int initialNeighborhoodRadius=1, uint8_t replaceValue=1) -> Image"""
    return _SimpleITK.VectorConfidenceConnected(*args, **kwargs)
class VectorConnectedComponentImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::VectorConnectedComponentImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_VectorConnectedComponentImageFilter

    def __init__(self):
        r"""__init__(VectorConnectedComponentImageFilter self) -> VectorConnectedComponentImageFilter"""
        _SimpleITK.VectorConnectedComponentImageFilter_swiginit(self, _SimpleITK.new_VectorConnectedComponentImageFilter())

    def SetDistanceThreshold(self, DistanceThreshold):
        r"""SetDistanceThreshold(VectorConnectedComponentImageFilter self, double DistanceThreshold)"""
        return _SimpleITK.VectorConnectedComponentImageFilter_SetDistanceThreshold(self, DistanceThreshold)

    def GetDistanceThreshold(self):
        r"""GetDistanceThreshold(VectorConnectedComponentImageFilter self) -> double"""
        return _SimpleITK.VectorConnectedComponentImageFilter_GetDistanceThreshold(self)

    def SetFullyConnected(self, FullyConnected):
        r"""SetFullyConnected(VectorConnectedComponentImageFilter self, bool FullyConnected)"""
        return _SimpleITK.VectorConnectedComponentImageFilter_SetFullyConnected(self, FullyConnected)

    def FullyConnectedOn(self):
        r"""FullyConnectedOn(VectorConnectedComponentImageFilter self)"""
        return _SimpleITK.VectorConnectedComponentImageFilter_FullyConnectedOn(self)

    def FullyConnectedOff(self):
        r"""FullyConnectedOff(VectorConnectedComponentImageFilter self)"""
        return _SimpleITK.VectorConnectedComponentImageFilter_FullyConnectedOff(self)

    def GetFullyConnected(self):
        r"""GetFullyConnected(VectorConnectedComponentImageFilter self) -> bool"""
        return _SimpleITK.VectorConnectedComponentImageFilter_GetFullyConnected(self)

    def GetName(self):
        r"""GetName(VectorConnectedComponentImageFilter self) -> std::string"""
        return _SimpleITK.VectorConnectedComponentImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(VectorConnectedComponentImageFilter self) -> std::string"""
        return _SimpleITK.VectorConnectedComponentImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(VectorConnectedComponentImageFilter self, Image image1) -> Image"""
        return _SimpleITK.VectorConnectedComponentImageFilter_Execute(self, image1)

# Register VectorConnectedComponentImageFilter in _SimpleITK:
_SimpleITK.VectorConnectedComponentImageFilter_swigregister(VectorConnectedComponentImageFilter)

def VectorConnectedComponent(image1, distanceThreshold=1.0, fullyConnected=False):
    r"""VectorConnectedComponent(Image image1, double distanceThreshold=1.0, bool fullyConnected=False) -> Image"""
    return _SimpleITK.VectorConnectedComponent(image1, distanceThreshold, fullyConnected)
class VectorIndexSelectionCastImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::VectorIndexSelectionCastImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_VectorIndexSelectionCastImageFilter

    def __init__(self):
        r"""__init__(VectorIndexSelectionCastImageFilter self) -> VectorIndexSelectionCastImageFilter"""
        _SimpleITK.VectorIndexSelectionCastImageFilter_swiginit(self, _SimpleITK.new_VectorIndexSelectionCastImageFilter())

    def SetIndex(self, Index):
        r"""SetIndex(VectorIndexSelectionCastImageFilter self, unsigned int Index)"""
        return _SimpleITK.VectorIndexSelectionCastImageFilter_SetIndex(self, Index)

    def GetIndex(self):
        r"""GetIndex(VectorIndexSelectionCastImageFilter self) -> unsigned int"""
        return _SimpleITK.VectorIndexSelectionCastImageFilter_GetIndex(self)

    def SetOutputPixelType(self, OutputPixelType):
        r"""SetOutputPixelType(VectorIndexSelectionCastImageFilter self, slicer_itk::simple::PixelIDValueEnum OutputPixelType)"""
        return _SimpleITK.VectorIndexSelectionCastImageFilter_SetOutputPixelType(self, OutputPixelType)

    def GetOutputPixelType(self):
        r"""GetOutputPixelType(VectorIndexSelectionCastImageFilter self) -> slicer_itk::simple::PixelIDValueEnum"""
        return _SimpleITK.VectorIndexSelectionCastImageFilter_GetOutputPixelType(self)

    def GetName(self):
        r"""GetName(VectorIndexSelectionCastImageFilter self) -> std::string"""
        return _SimpleITK.VectorIndexSelectionCastImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(VectorIndexSelectionCastImageFilter self) -> std::string"""
        return _SimpleITK.VectorIndexSelectionCastImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(VectorIndexSelectionCastImageFilter self, Image image1) -> Image"""
        return _SimpleITK.VectorIndexSelectionCastImageFilter_Execute(self, image1)

# Register VectorIndexSelectionCastImageFilter in _SimpleITK:
_SimpleITK.VectorIndexSelectionCastImageFilter_swigregister(VectorIndexSelectionCastImageFilter)

def VectorIndexSelectionCast(*args, **kwargs):
    r"""VectorIndexSelectionCast(Image image1, unsigned int index=0, slicer_itk::simple::PixelIDValueEnum outputPixelType=sitkUnknown) -> Image"""
    return _SimpleITK.VectorIndexSelectionCast(*args, **kwargs)
class VectorMagnitudeImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::VectorMagnitudeImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_VectorMagnitudeImageFilter

    def __init__(self):
        r"""__init__(VectorMagnitudeImageFilter self) -> VectorMagnitudeImageFilter"""
        _SimpleITK.VectorMagnitudeImageFilter_swiginit(self, _SimpleITK.new_VectorMagnitudeImageFilter())

    def GetName(self):
        r"""GetName(VectorMagnitudeImageFilter self) -> std::string"""
        return _SimpleITK.VectorMagnitudeImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(VectorMagnitudeImageFilter self) -> std::string"""
        return _SimpleITK.VectorMagnitudeImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(VectorMagnitudeImageFilter self, Image image1) -> Image"""
        return _SimpleITK.VectorMagnitudeImageFilter_Execute(self, image1)

# Register VectorMagnitudeImageFilter in _SimpleITK:
_SimpleITK.VectorMagnitudeImageFilter_swigregister(VectorMagnitudeImageFilter)

def VectorMagnitude(image1):
    r"""VectorMagnitude(Image image1) -> Image"""
    return _SimpleITK.VectorMagnitude(image1)
class VotingBinaryHoleFillingImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::VotingBinaryHoleFillingImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_VotingBinaryHoleFillingImageFilter

    def __init__(self):
        r"""__init__(VotingBinaryHoleFillingImageFilter self) -> VotingBinaryHoleFillingImageFilter"""
        _SimpleITK.VotingBinaryHoleFillingImageFilter_swiginit(self, _SimpleITK.new_VotingBinaryHoleFillingImageFilter())

    def SetRadius(self, *args):
        r"""
        SetRadius(VotingBinaryHoleFillingImageFilter self, VectorUInt32 Radius)
        SetRadius(VotingBinaryHoleFillingImageFilter self, unsigned int value)
        """
        return _SimpleITK.VotingBinaryHoleFillingImageFilter_SetRadius(self, *args)

    def GetRadius(self):
        r"""GetRadius(VotingBinaryHoleFillingImageFilter self) -> VectorUInt32"""
        return _SimpleITK.VotingBinaryHoleFillingImageFilter_GetRadius(self)

    def SetMajorityThreshold(self, MajorityThreshold):
        r"""SetMajorityThreshold(VotingBinaryHoleFillingImageFilter self, unsigned int MajorityThreshold)"""
        return _SimpleITK.VotingBinaryHoleFillingImageFilter_SetMajorityThreshold(self, MajorityThreshold)

    def GetMajorityThreshold(self):
        r"""GetMajorityThreshold(VotingBinaryHoleFillingImageFilter self) -> unsigned int"""
        return _SimpleITK.VotingBinaryHoleFillingImageFilter_GetMajorityThreshold(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(VotingBinaryHoleFillingImageFilter self, double ForegroundValue)"""
        return _SimpleITK.VotingBinaryHoleFillingImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(VotingBinaryHoleFillingImageFilter self) -> double"""
        return _SimpleITK.VotingBinaryHoleFillingImageFilter_GetForegroundValue(self)

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(VotingBinaryHoleFillingImageFilter self, double BackgroundValue)"""
        return _SimpleITK.VotingBinaryHoleFillingImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(VotingBinaryHoleFillingImageFilter self) -> double"""
        return _SimpleITK.VotingBinaryHoleFillingImageFilter_GetBackgroundValue(self)

    def GetName(self):
        r"""GetName(VotingBinaryHoleFillingImageFilter self) -> std::string"""
        return _SimpleITK.VotingBinaryHoleFillingImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(VotingBinaryHoleFillingImageFilter self) -> std::string"""
        return _SimpleITK.VotingBinaryHoleFillingImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(VotingBinaryHoleFillingImageFilter self, Image image1) -> Image"""
        return _SimpleITK.VotingBinaryHoleFillingImageFilter_Execute(self, image1)

# Register VotingBinaryHoleFillingImageFilter in _SimpleITK:
_SimpleITK.VotingBinaryHoleFillingImageFilter_swigregister(VotingBinaryHoleFillingImageFilter)

def VotingBinaryHoleFilling(*args, **kwargs):
    r"""VotingBinaryHoleFilling(Image image1, VectorUInt32 radius=std::vector< unsigned int >(3, 1), unsigned int majorityThreshold=1, double foregroundValue=1.0, double backgroundValue=0.0) -> Image"""
    return _SimpleITK.VotingBinaryHoleFilling(*args, **kwargs)
class VotingBinaryImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::VotingBinaryImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_VotingBinaryImageFilter

    def __init__(self):
        r"""__init__(VotingBinaryImageFilter self) -> VotingBinaryImageFilter"""
        _SimpleITK.VotingBinaryImageFilter_swiginit(self, _SimpleITK.new_VotingBinaryImageFilter())

    def SetRadius(self, *args):
        r"""
        SetRadius(VotingBinaryImageFilter self, VectorUInt32 Radius)
        SetRadius(VotingBinaryImageFilter self, unsigned int value)
        """
        return _SimpleITK.VotingBinaryImageFilter_SetRadius(self, *args)

    def GetRadius(self):
        r"""GetRadius(VotingBinaryImageFilter self) -> VectorUInt32"""
        return _SimpleITK.VotingBinaryImageFilter_GetRadius(self)

    def SetBirthThreshold(self, BirthThreshold):
        r"""SetBirthThreshold(VotingBinaryImageFilter self, unsigned int BirthThreshold)"""
        return _SimpleITK.VotingBinaryImageFilter_SetBirthThreshold(self, BirthThreshold)

    def GetBirthThreshold(self):
        r"""GetBirthThreshold(VotingBinaryImageFilter self) -> unsigned int"""
        return _SimpleITK.VotingBinaryImageFilter_GetBirthThreshold(self)

    def SetSurvivalThreshold(self, SurvivalThreshold):
        r"""SetSurvivalThreshold(VotingBinaryImageFilter self, unsigned int SurvivalThreshold)"""
        return _SimpleITK.VotingBinaryImageFilter_SetSurvivalThreshold(self, SurvivalThreshold)

    def GetSurvivalThreshold(self):
        r"""GetSurvivalThreshold(VotingBinaryImageFilter self) -> unsigned int"""
        return _SimpleITK.VotingBinaryImageFilter_GetSurvivalThreshold(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(VotingBinaryImageFilter self, double ForegroundValue)"""
        return _SimpleITK.VotingBinaryImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(VotingBinaryImageFilter self) -> double"""
        return _SimpleITK.VotingBinaryImageFilter_GetForegroundValue(self)

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(VotingBinaryImageFilter self, double BackgroundValue)"""
        return _SimpleITK.VotingBinaryImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(VotingBinaryImageFilter self) -> double"""
        return _SimpleITK.VotingBinaryImageFilter_GetBackgroundValue(self)

    def GetName(self):
        r"""GetName(VotingBinaryImageFilter self) -> std::string"""
        return _SimpleITK.VotingBinaryImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(VotingBinaryImageFilter self) -> std::string"""
        return _SimpleITK.VotingBinaryImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(VotingBinaryImageFilter self, Image image1) -> Image"""
        return _SimpleITK.VotingBinaryImageFilter_Execute(self, image1)

# Register VotingBinaryImageFilter in _SimpleITK:
_SimpleITK.VotingBinaryImageFilter_swigregister(VotingBinaryImageFilter)

def VotingBinary(*args, **kwargs):
    r"""VotingBinary(Image image1, VectorUInt32 radius=std::vector< unsigned int >(3, 1), unsigned int birthThreshold=1, unsigned int survivalThreshold=1, double foregroundValue=1.0, double backgroundValue=0.0) -> Image"""
    return _SimpleITK.VotingBinary(*args, **kwargs)
class VotingBinaryIterativeHoleFillingImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::VotingBinaryIterativeHoleFillingImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_VotingBinaryIterativeHoleFillingImageFilter

    def __init__(self):
        r"""__init__(VotingBinaryIterativeHoleFillingImageFilter self) -> VotingBinaryIterativeHoleFillingImageFilter"""
        _SimpleITK.VotingBinaryIterativeHoleFillingImageFilter_swiginit(self, _SimpleITK.new_VotingBinaryIterativeHoleFillingImageFilter())

    def SetRadius(self, *args):
        r"""
        SetRadius(VotingBinaryIterativeHoleFillingImageFilter self, VectorUInt32 Radius)
        SetRadius(VotingBinaryIterativeHoleFillingImageFilter self, unsigned int value)
        """
        return _SimpleITK.VotingBinaryIterativeHoleFillingImageFilter_SetRadius(self, *args)

    def GetRadius(self):
        r"""GetRadius(VotingBinaryIterativeHoleFillingImageFilter self) -> VectorUInt32"""
        return _SimpleITK.VotingBinaryIterativeHoleFillingImageFilter_GetRadius(self)

    def SetMaximumNumberOfIterations(self, MaximumNumberOfIterations):
        r"""SetMaximumNumberOfIterations(VotingBinaryIterativeHoleFillingImageFilter self, unsigned int MaximumNumberOfIterations)"""
        return _SimpleITK.VotingBinaryIterativeHoleFillingImageFilter_SetMaximumNumberOfIterations(self, MaximumNumberOfIterations)

    def GetMaximumNumberOfIterations(self):
        r"""GetMaximumNumberOfIterations(VotingBinaryIterativeHoleFillingImageFilter self) -> unsigned int"""
        return _SimpleITK.VotingBinaryIterativeHoleFillingImageFilter_GetMaximumNumberOfIterations(self)

    def SetMajorityThreshold(self, MajorityThreshold):
        r"""SetMajorityThreshold(VotingBinaryIterativeHoleFillingImageFilter self, unsigned int MajorityThreshold)"""
        return _SimpleITK.VotingBinaryIterativeHoleFillingImageFilter_SetMajorityThreshold(self, MajorityThreshold)

    def GetMajorityThreshold(self):
        r"""GetMajorityThreshold(VotingBinaryIterativeHoleFillingImageFilter self) -> unsigned int"""
        return _SimpleITK.VotingBinaryIterativeHoleFillingImageFilter_GetMajorityThreshold(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(VotingBinaryIterativeHoleFillingImageFilter self, double ForegroundValue)"""
        return _SimpleITK.VotingBinaryIterativeHoleFillingImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(VotingBinaryIterativeHoleFillingImageFilter self) -> double"""
        return _SimpleITK.VotingBinaryIterativeHoleFillingImageFilter_GetForegroundValue(self)

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(VotingBinaryIterativeHoleFillingImageFilter self, double BackgroundValue)"""
        return _SimpleITK.VotingBinaryIterativeHoleFillingImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(VotingBinaryIterativeHoleFillingImageFilter self) -> double"""
        return _SimpleITK.VotingBinaryIterativeHoleFillingImageFilter_GetBackgroundValue(self)

    def GetName(self):
        r"""GetName(VotingBinaryIterativeHoleFillingImageFilter self) -> std::string"""
        return _SimpleITK.VotingBinaryIterativeHoleFillingImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(VotingBinaryIterativeHoleFillingImageFilter self) -> std::string"""
        return _SimpleITK.VotingBinaryIterativeHoleFillingImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(VotingBinaryIterativeHoleFillingImageFilter self, Image image1) -> Image"""
        return _SimpleITK.VotingBinaryIterativeHoleFillingImageFilter_Execute(self, image1)

# Register VotingBinaryIterativeHoleFillingImageFilter in _SimpleITK:
_SimpleITK.VotingBinaryIterativeHoleFillingImageFilter_swigregister(VotingBinaryIterativeHoleFillingImageFilter)

def VotingBinaryIterativeHoleFilling(*args, **kwargs):
    r"""VotingBinaryIterativeHoleFilling(Image image1, VectorUInt32 radius=std::vector< unsigned int >(3, 1), unsigned int maximumNumberOfIterations=10, unsigned int majorityThreshold=1, double foregroundValue=1.0, double backgroundValue=0.0) -> Image"""
    return _SimpleITK.VotingBinaryIterativeHoleFilling(*args, **kwargs)
class WarpImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::WarpImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_WarpImageFilter

    def __init__(self):
        r"""__init__(WarpImageFilter self) -> WarpImageFilter"""
        _SimpleITK.WarpImageFilter_swiginit(self, _SimpleITK.new_WarpImageFilter())

    def SetInterpolator(self, Interpolator):
        r"""SetInterpolator(WarpImageFilter self, slicer_itk::simple::InterpolatorEnum Interpolator)"""
        return _SimpleITK.WarpImageFilter_SetInterpolator(self, Interpolator)

    def GetInterpolator(self):
        r"""GetInterpolator(WarpImageFilter self) -> slicer_itk::simple::InterpolatorEnum"""
        return _SimpleITK.WarpImageFilter_GetInterpolator(self)

    def SetOutputSize(self, OutputSize):
        r"""SetOutputSize(WarpImageFilter self, VectorUInt32 OutputSize)"""
        return _SimpleITK.WarpImageFilter_SetOutputSize(self, OutputSize)

    def GetOutputSize(self):
        r"""GetOutputSize(WarpImageFilter self) -> VectorUInt32"""
        return _SimpleITK.WarpImageFilter_GetOutputSize(self)

    def SetOutputOrigin(self, OutputOrigin):
        r"""SetOutputOrigin(WarpImageFilter self, VectorDouble OutputOrigin)"""
        return _SimpleITK.WarpImageFilter_SetOutputOrigin(self, OutputOrigin)

    def GetOutputOrigin(self):
        r"""GetOutputOrigin(WarpImageFilter self) -> VectorDouble"""
        return _SimpleITK.WarpImageFilter_GetOutputOrigin(self)

    def SetOutputSpacing(self, OutputSpacing):
        r"""SetOutputSpacing(WarpImageFilter self, VectorDouble OutputSpacing)"""
        return _SimpleITK.WarpImageFilter_SetOutputSpacing(self, OutputSpacing)

    def GetOutputSpacing(self):
        r"""GetOutputSpacing(WarpImageFilter self) -> VectorDouble"""
        return _SimpleITK.WarpImageFilter_GetOutputSpacing(self)

    def SetOutputDirection(self, OutputDirection):
        r"""SetOutputDirection(WarpImageFilter self, VectorDouble OutputDirection)"""
        return _SimpleITK.WarpImageFilter_SetOutputDirection(self, OutputDirection)

    def GetOutputDirection(self):
        r"""GetOutputDirection(WarpImageFilter self) -> VectorDouble"""
        return _SimpleITK.WarpImageFilter_GetOutputDirection(self)

    def SetEdgePaddingValue(self, EdgePaddingValue):
        r"""SetEdgePaddingValue(WarpImageFilter self, double EdgePaddingValue)"""
        return _SimpleITK.WarpImageFilter_SetEdgePaddingValue(self, EdgePaddingValue)

    def GetEdgePaddingValue(self):
        r"""GetEdgePaddingValue(WarpImageFilter self) -> double"""
        return _SimpleITK.WarpImageFilter_GetEdgePaddingValue(self)

    def GetName(self):
        r"""GetName(WarpImageFilter self) -> std::string"""
        return _SimpleITK.WarpImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(WarpImageFilter self) -> std::string"""
        return _SimpleITK.WarpImageFilter___str__(self)

    def Execute(self, image, displacementField):
        r"""Execute(WarpImageFilter self, Image image, Image displacementField) -> Image"""
        return _SimpleITK.WarpImageFilter_Execute(self, image, displacementField)

    def SetOutputParameteresFromImage(self, refImage):
        r"""SetOutputParameteresFromImage(WarpImageFilter self, Image refImage)"""
        return _SimpleITK.WarpImageFilter_SetOutputParameteresFromImage(self, refImage)

# Register WarpImageFilter in _SimpleITK:
_SimpleITK.WarpImageFilter_swigregister(WarpImageFilter)

def Warp(*args, **kwargs):
    r"""Warp(Image image, Image displacementField, slicer_itk::simple::InterpolatorEnum interpolator=sitkLinear, VectorUInt32 outputSize=std::vector< uint32_t >(3, 0), VectorDouble outputOrigin=std::vector< double >(3, 0.0), VectorDouble outputSpacing=std::vector< double >(3, 1.0), VectorDouble outputDirection=std::vector< double >(), double edgePaddingValue=0.0) -> Image"""
    return _SimpleITK.Warp(*args, **kwargs)
class WhiteTopHatImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::WhiteTopHatImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_WhiteTopHatImageFilter

    def __init__(self):
        r"""__init__(WhiteTopHatImageFilter self) -> WhiteTopHatImageFilter"""
        _SimpleITK.WhiteTopHatImageFilter_swiginit(self, _SimpleITK.new_WhiteTopHatImageFilter())

    def SetKernelRadius(self, *args):
        r"""
        SetKernelRadius(WhiteTopHatImageFilter self, VectorUInt32 KernelRadius)
        SetKernelRadius(WhiteTopHatImageFilter self, unsigned int value)
        """
        return _SimpleITK.WhiteTopHatImageFilter_SetKernelRadius(self, *args)

    def GetKernelRadius(self):
        r"""GetKernelRadius(WhiteTopHatImageFilter self) -> VectorUInt32"""
        return _SimpleITK.WhiteTopHatImageFilter_GetKernelRadius(self)

    def SetKernelType(self, KernelType):
        r"""SetKernelType(WhiteTopHatImageFilter self, slicer_itk::simple::KernelEnum KernelType)"""
        return _SimpleITK.WhiteTopHatImageFilter_SetKernelType(self, KernelType)

    def GetKernelType(self):
        r"""GetKernelType(WhiteTopHatImageFilter self) -> slicer_itk::simple::KernelEnum"""
        return _SimpleITK.WhiteTopHatImageFilter_GetKernelType(self)

    def SetSafeBorder(self, SafeBorder):
        r"""SetSafeBorder(WhiteTopHatImageFilter self, bool SafeBorder)"""
        return _SimpleITK.WhiteTopHatImageFilter_SetSafeBorder(self, SafeBorder)

    def SafeBorderOn(self):
        r"""SafeBorderOn(WhiteTopHatImageFilter self)"""
        return _SimpleITK.WhiteTopHatImageFilter_SafeBorderOn(self)

    def SafeBorderOff(self):
        r"""SafeBorderOff(WhiteTopHatImageFilter self)"""
        return _SimpleITK.WhiteTopHatImageFilter_SafeBorderOff(self)

    def GetSafeBorder(self):
        r"""GetSafeBorder(WhiteTopHatImageFilter self) -> bool"""
        return _SimpleITK.WhiteTopHatImageFilter_GetSafeBorder(self)

    def GetName(self):
        r"""GetName(WhiteTopHatImageFilter self) -> std::string"""
        return _SimpleITK.WhiteTopHatImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(WhiteTopHatImageFilter self) -> std::string"""
        return _SimpleITK.WhiteTopHatImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(WhiteTopHatImageFilter self, Image image1) -> Image"""
        return _SimpleITK.WhiteTopHatImageFilter_Execute(self, image1)

# Register WhiteTopHatImageFilter in _SimpleITK:
_SimpleITK.WhiteTopHatImageFilter_swigregister(WhiteTopHatImageFilter)

def WhiteTopHat(*args, **kwargs):
    r"""WhiteTopHat(Image image1, VectorUInt32 kernelRadius=std::vector< uint32_t >(3, 1), slicer_itk::simple::KernelEnum kernelType=sitkBall, bool safeBorder=True) -> Image"""
    return _SimpleITK.WhiteTopHat(*args, **kwargs)
class WienerDeconvolutionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::WienerDeconvolutionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_WienerDeconvolutionImageFilter

    def __init__(self):
        r"""__init__(WienerDeconvolutionImageFilter self) -> WienerDeconvolutionImageFilter"""
        _SimpleITK.WienerDeconvolutionImageFilter_swiginit(self, _SimpleITK.new_WienerDeconvolutionImageFilter())

    def SetNoiseVariance(self, NoiseVariance):
        r"""SetNoiseVariance(WienerDeconvolutionImageFilter self, double NoiseVariance)"""
        return _SimpleITK.WienerDeconvolutionImageFilter_SetNoiseVariance(self, NoiseVariance)

    def GetNoiseVariance(self):
        r"""GetNoiseVariance(WienerDeconvolutionImageFilter self) -> double"""
        return _SimpleITK.WienerDeconvolutionImageFilter_GetNoiseVariance(self)

    def SetNormalize(self, Normalize):
        r"""SetNormalize(WienerDeconvolutionImageFilter self, bool Normalize)"""
        return _SimpleITK.WienerDeconvolutionImageFilter_SetNormalize(self, Normalize)

    def NormalizeOn(self):
        r"""NormalizeOn(WienerDeconvolutionImageFilter self)"""
        return _SimpleITK.WienerDeconvolutionImageFilter_NormalizeOn(self)

    def NormalizeOff(self):
        r"""NormalizeOff(WienerDeconvolutionImageFilter self)"""
        return _SimpleITK.WienerDeconvolutionImageFilter_NormalizeOff(self)

    def GetNormalize(self):
        r"""GetNormalize(WienerDeconvolutionImageFilter self) -> bool"""
        return _SimpleITK.WienerDeconvolutionImageFilter_GetNormalize(self)
    ZERO_PAD = _SimpleITK.WienerDeconvolutionImageFilter_ZERO_PAD
    
    ZERO_FLUX_NEUMANN_PAD = _SimpleITK.WienerDeconvolutionImageFilter_ZERO_FLUX_NEUMANN_PAD
    
    PERIODIC_PAD = _SimpleITK.WienerDeconvolutionImageFilter_PERIODIC_PAD
    

    def SetBoundaryCondition(self, BoundaryCondition):
        r"""SetBoundaryCondition(WienerDeconvolutionImageFilter self, slicer_itk::simple::WienerDeconvolutionImageFilter::BoundaryConditionType BoundaryCondition)"""
        return _SimpleITK.WienerDeconvolutionImageFilter_SetBoundaryCondition(self, BoundaryCondition)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(WienerDeconvolutionImageFilter self) -> slicer_itk::simple::WienerDeconvolutionImageFilter::BoundaryConditionType"""
        return _SimpleITK.WienerDeconvolutionImageFilter_GetBoundaryCondition(self)
    SAME = _SimpleITK.WienerDeconvolutionImageFilter_SAME
    
    VALID = _SimpleITK.WienerDeconvolutionImageFilter_VALID
    

    def SetOutputRegionMode(self, OutputRegionMode):
        r"""SetOutputRegionMode(WienerDeconvolutionImageFilter self, slicer_itk::simple::WienerDeconvolutionImageFilter::OutputRegionModeType OutputRegionMode)"""
        return _SimpleITK.WienerDeconvolutionImageFilter_SetOutputRegionMode(self, OutputRegionMode)

    def GetOutputRegionMode(self):
        r"""GetOutputRegionMode(WienerDeconvolutionImageFilter self) -> slicer_itk::simple::WienerDeconvolutionImageFilter::OutputRegionModeType"""
        return _SimpleITK.WienerDeconvolutionImageFilter_GetOutputRegionMode(self)

    def GetName(self):
        r"""GetName(WienerDeconvolutionImageFilter self) -> std::string"""
        return _SimpleITK.WienerDeconvolutionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(WienerDeconvolutionImageFilter self) -> std::string"""
        return _SimpleITK.WienerDeconvolutionImageFilter___str__(self)

    def Execute(self, image1, image2):
        r"""Execute(WienerDeconvolutionImageFilter self, Image image1, Image image2) -> Image"""
        return _SimpleITK.WienerDeconvolutionImageFilter_Execute(self, image1, image2)

# Register WienerDeconvolutionImageFilter in _SimpleITK:
_SimpleITK.WienerDeconvolutionImageFilter_swigregister(WienerDeconvolutionImageFilter)

def WienerDeconvolution(*args, **kwargs):
    r"""WienerDeconvolution(Image image1, Image image2, double noiseVariance=0.0, bool normalize=False, slicer_itk::simple::WienerDeconvolutionImageFilter::BoundaryConditionType boundaryCondition=ZERO_FLUX_NEUMANN_PAD, slicer_itk::simple::WienerDeconvolutionImageFilter::OutputRegionModeType outputRegionMode=SAME) -> Image"""
    return _SimpleITK.WienerDeconvolution(*args, **kwargs)
class WrapPadImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::WrapPadImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_WrapPadImageFilter

    def __init__(self):
        r"""__init__(WrapPadImageFilter self) -> WrapPadImageFilter"""
        _SimpleITK.WrapPadImageFilter_swiginit(self, _SimpleITK.new_WrapPadImageFilter())

    def SetPadLowerBound(self, PadLowerBound):
        r"""SetPadLowerBound(WrapPadImageFilter self, VectorUInt32 PadLowerBound)"""
        return _SimpleITK.WrapPadImageFilter_SetPadLowerBound(self, PadLowerBound)

    def GetPadLowerBound(self):
        r"""GetPadLowerBound(WrapPadImageFilter self) -> VectorUInt32"""
        return _SimpleITK.WrapPadImageFilter_GetPadLowerBound(self)

    def SetPadUpperBound(self, PadUpperBound):
        r"""SetPadUpperBound(WrapPadImageFilter self, VectorUInt32 PadUpperBound)"""
        return _SimpleITK.WrapPadImageFilter_SetPadUpperBound(self, PadUpperBound)

    def GetPadUpperBound(self):
        r"""GetPadUpperBound(WrapPadImageFilter self) -> VectorUInt32"""
        return _SimpleITK.WrapPadImageFilter_GetPadUpperBound(self)

    def GetName(self):
        r"""GetName(WrapPadImageFilter self) -> std::string"""
        return _SimpleITK.WrapPadImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(WrapPadImageFilter self) -> std::string"""
        return _SimpleITK.WrapPadImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(WrapPadImageFilter self, Image image1) -> Image"""
        return _SimpleITK.WrapPadImageFilter_Execute(self, image1)

# Register WrapPadImageFilter in _SimpleITK:
_SimpleITK.WrapPadImageFilter_swigregister(WrapPadImageFilter)

def WrapPad(*args, **kwargs):
    r"""WrapPad(Image image1, VectorUInt32 padLowerBound=std::vector< unsigned int >(3, 0), VectorUInt32 padUpperBound=std::vector< unsigned int >(3, 0)) -> Image"""
    return _SimpleITK.WrapPad(*args, **kwargs)
class XorImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::XorImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_XorImageFilter

    def __init__(self):
        r"""__init__(XorImageFilter self) -> XorImageFilter"""
        _SimpleITK.XorImageFilter_swiginit(self, _SimpleITK.new_XorImageFilter())

    def GetName(self):
        r"""GetName(XorImageFilter self) -> std::string"""
        return _SimpleITK.XorImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(XorImageFilter self) -> std::string"""
        return _SimpleITK.XorImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(XorImageFilter self, Image image1, Image image2) -> Image
        Execute(XorImageFilter self, Image image1, int constant) -> Image
        Execute(XorImageFilter self, int constant, Image image2) -> Image
        """
        return _SimpleITK.XorImageFilter_Execute(self, *args)

# Register XorImageFilter in _SimpleITK:
_SimpleITK.XorImageFilter_swigregister(XorImageFilter)

def Xor(*args):
    r"""
    Xor(Image image1, Image image2) -> Image
    Xor(Image image1, int constant) -> Image
    Xor(int constant, Image image2) -> Image
    """
    return _SimpleITK.Xor(*args)
class YenThresholdImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::YenThresholdImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_YenThresholdImageFilter

    def __init__(self):
        r"""__init__(YenThresholdImageFilter self) -> YenThresholdImageFilter"""
        _SimpleITK.YenThresholdImageFilter_swiginit(self, _SimpleITK.new_YenThresholdImageFilter())

    def SetInsideValue(self, InsideValue):
        r"""SetInsideValue(YenThresholdImageFilter self, uint8_t InsideValue)"""
        return _SimpleITK.YenThresholdImageFilter_SetInsideValue(self, InsideValue)

    def GetInsideValue(self):
        r"""GetInsideValue(YenThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.YenThresholdImageFilter_GetInsideValue(self)

    def SetOutsideValue(self, OutsideValue):
        r"""SetOutsideValue(YenThresholdImageFilter self, uint8_t OutsideValue)"""
        return _SimpleITK.YenThresholdImageFilter_SetOutsideValue(self, OutsideValue)

    def GetOutsideValue(self):
        r"""GetOutsideValue(YenThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.YenThresholdImageFilter_GetOutsideValue(self)

    def SetNumberOfHistogramBins(self, NumberOfHistogramBins):
        r"""SetNumberOfHistogramBins(YenThresholdImageFilter self, uint32_t NumberOfHistogramBins)"""
        return _SimpleITK.YenThresholdImageFilter_SetNumberOfHistogramBins(self, NumberOfHistogramBins)

    def GetNumberOfHistogramBins(self):
        r"""GetNumberOfHistogramBins(YenThresholdImageFilter self) -> uint32_t"""
        return _SimpleITK.YenThresholdImageFilter_GetNumberOfHistogramBins(self)

    def SetMaskOutput(self, MaskOutput):
        r"""SetMaskOutput(YenThresholdImageFilter self, bool MaskOutput)"""
        return _SimpleITK.YenThresholdImageFilter_SetMaskOutput(self, MaskOutput)

    def MaskOutputOn(self):
        r"""MaskOutputOn(YenThresholdImageFilter self)"""
        return _SimpleITK.YenThresholdImageFilter_MaskOutputOn(self)

    def MaskOutputOff(self):
        r"""MaskOutputOff(YenThresholdImageFilter self)"""
        return _SimpleITK.YenThresholdImageFilter_MaskOutputOff(self)

    def GetMaskOutput(self):
        r"""GetMaskOutput(YenThresholdImageFilter self) -> bool"""
        return _SimpleITK.YenThresholdImageFilter_GetMaskOutput(self)

    def SetMaskValue(self, MaskValue):
        r"""SetMaskValue(YenThresholdImageFilter self, uint8_t MaskValue)"""
        return _SimpleITK.YenThresholdImageFilter_SetMaskValue(self, MaskValue)

    def GetMaskValue(self):
        r"""GetMaskValue(YenThresholdImageFilter self) -> uint8_t"""
        return _SimpleITK.YenThresholdImageFilter_GetMaskValue(self)

    def GetThreshold(self):
        r"""GetThreshold(YenThresholdImageFilter self) -> double"""
        return _SimpleITK.YenThresholdImageFilter_GetThreshold(self)

    def GetName(self):
        r"""GetName(YenThresholdImageFilter self) -> std::string"""
        return _SimpleITK.YenThresholdImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(YenThresholdImageFilter self) -> std::string"""
        return _SimpleITK.YenThresholdImageFilter___str__(self)

    def Execute(self, *args):
        r"""
        Execute(YenThresholdImageFilter self, Image image, Image maskImage) -> Image
        Execute(YenThresholdImageFilter self, Image image) -> Image
        """
        return _SimpleITK.YenThresholdImageFilter_Execute(self, *args)

# Register YenThresholdImageFilter in _SimpleITK:
_SimpleITK.YenThresholdImageFilter_swigregister(YenThresholdImageFilter)

def YenThreshold(*args):
    r"""
    YenThreshold(Image image, Image maskImage, uint8_t insideValue=1, uint8_t outsideValue=0, uint32_t numberOfHistogramBins=256, bool maskOutput=True, uint8_t maskValue=255) -> Image
    YenThreshold(Image image, uint8_t insideValue=1, uint8_t outsideValue=0, uint32_t numberOfHistogramBins=256, bool maskOutput=True, uint8_t maskValue=255) -> Image
    """
    return _SimpleITK.YenThreshold(*args)
class ZeroCrossingBasedEdgeDetectionImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ZeroCrossingBasedEdgeDetectionImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ZeroCrossingBasedEdgeDetectionImageFilter

    def __init__(self):
        r"""__init__(ZeroCrossingBasedEdgeDetectionImageFilter self) -> ZeroCrossingBasedEdgeDetectionImageFilter"""
        _SimpleITK.ZeroCrossingBasedEdgeDetectionImageFilter_swiginit(self, _SimpleITK.new_ZeroCrossingBasedEdgeDetectionImageFilter())

    def SetVariance(self, Variance):
        r"""SetVariance(ZeroCrossingBasedEdgeDetectionImageFilter self, double Variance)"""
        return _SimpleITK.ZeroCrossingBasedEdgeDetectionImageFilter_SetVariance(self, Variance)

    def GetVariance(self):
        r"""GetVariance(ZeroCrossingBasedEdgeDetectionImageFilter self) -> double"""
        return _SimpleITK.ZeroCrossingBasedEdgeDetectionImageFilter_GetVariance(self)

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(ZeroCrossingBasedEdgeDetectionImageFilter self, uint8_t ForegroundValue)"""
        return _SimpleITK.ZeroCrossingBasedEdgeDetectionImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(ZeroCrossingBasedEdgeDetectionImageFilter self) -> uint8_t"""
        return _SimpleITK.ZeroCrossingBasedEdgeDetectionImageFilter_GetForegroundValue(self)

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(ZeroCrossingBasedEdgeDetectionImageFilter self, uint8_t BackgroundValue)"""
        return _SimpleITK.ZeroCrossingBasedEdgeDetectionImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(ZeroCrossingBasedEdgeDetectionImageFilter self) -> uint8_t"""
        return _SimpleITK.ZeroCrossingBasedEdgeDetectionImageFilter_GetBackgroundValue(self)

    def SetMaximumError(self, MaximumError):
        r"""SetMaximumError(ZeroCrossingBasedEdgeDetectionImageFilter self, double MaximumError)"""
        return _SimpleITK.ZeroCrossingBasedEdgeDetectionImageFilter_SetMaximumError(self, MaximumError)

    def GetMaximumError(self):
        r"""GetMaximumError(ZeroCrossingBasedEdgeDetectionImageFilter self) -> double"""
        return _SimpleITK.ZeroCrossingBasedEdgeDetectionImageFilter_GetMaximumError(self)

    def GetName(self):
        r"""GetName(ZeroCrossingBasedEdgeDetectionImageFilter self) -> std::string"""
        return _SimpleITK.ZeroCrossingBasedEdgeDetectionImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ZeroCrossingBasedEdgeDetectionImageFilter self) -> std::string"""
        return _SimpleITK.ZeroCrossingBasedEdgeDetectionImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ZeroCrossingBasedEdgeDetectionImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ZeroCrossingBasedEdgeDetectionImageFilter_Execute(self, image1)

# Register ZeroCrossingBasedEdgeDetectionImageFilter in _SimpleITK:
_SimpleITK.ZeroCrossingBasedEdgeDetectionImageFilter_swigregister(ZeroCrossingBasedEdgeDetectionImageFilter)

def ZeroCrossingBasedEdgeDetection(image1, variance=1.0, foregroundValue=1, backgroundValue=0, maximumError=0.1):
    r"""ZeroCrossingBasedEdgeDetection(Image image1, double variance=1.0, uint8_t foregroundValue=1, uint8_t backgroundValue=0, double maximumError=0.1) -> Image"""
    return _SimpleITK.ZeroCrossingBasedEdgeDetection(image1, variance, foregroundValue, backgroundValue, maximumError)
class ZeroCrossingImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ZeroCrossingImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ZeroCrossingImageFilter

    def __init__(self):
        r"""__init__(ZeroCrossingImageFilter self) -> ZeroCrossingImageFilter"""
        _SimpleITK.ZeroCrossingImageFilter_swiginit(self, _SimpleITK.new_ZeroCrossingImageFilter())

    def SetForegroundValue(self, ForegroundValue):
        r"""SetForegroundValue(ZeroCrossingImageFilter self, uint8_t ForegroundValue)"""
        return _SimpleITK.ZeroCrossingImageFilter_SetForegroundValue(self, ForegroundValue)

    def GetForegroundValue(self):
        r"""GetForegroundValue(ZeroCrossingImageFilter self) -> uint8_t"""
        return _SimpleITK.ZeroCrossingImageFilter_GetForegroundValue(self)

    def SetBackgroundValue(self, BackgroundValue):
        r"""SetBackgroundValue(ZeroCrossingImageFilter self, uint8_t BackgroundValue)"""
        return _SimpleITK.ZeroCrossingImageFilter_SetBackgroundValue(self, BackgroundValue)

    def GetBackgroundValue(self):
        r"""GetBackgroundValue(ZeroCrossingImageFilter self) -> uint8_t"""
        return _SimpleITK.ZeroCrossingImageFilter_GetBackgroundValue(self)

    def GetName(self):
        r"""GetName(ZeroCrossingImageFilter self) -> std::string"""
        return _SimpleITK.ZeroCrossingImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ZeroCrossingImageFilter self) -> std::string"""
        return _SimpleITK.ZeroCrossingImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ZeroCrossingImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ZeroCrossingImageFilter_Execute(self, image1)

# Register ZeroCrossingImageFilter in _SimpleITK:
_SimpleITK.ZeroCrossingImageFilter_swigregister(ZeroCrossingImageFilter)

def ZeroCrossing(image1, foregroundValue=1, backgroundValue=0):
    r"""ZeroCrossing(Image image1, uint8_t foregroundValue=1, uint8_t backgroundValue=0) -> Image"""
    return _SimpleITK.ZeroCrossing(image1, foregroundValue, backgroundValue)
class ZeroFluxNeumannPadImageFilter(ImageFilter):
    r"""Proxy of C++ slicer_itk::simple::ZeroFluxNeumannPadImageFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimpleITK.delete_ZeroFluxNeumannPadImageFilter

    def __init__(self):
        r"""__init__(ZeroFluxNeumannPadImageFilter self) -> ZeroFluxNeumannPadImageFilter"""
        _SimpleITK.ZeroFluxNeumannPadImageFilter_swiginit(self, _SimpleITK.new_ZeroFluxNeumannPadImageFilter())

    def SetPadLowerBound(self, PadLowerBound):
        r"""SetPadLowerBound(ZeroFluxNeumannPadImageFilter self, VectorUInt32 PadLowerBound)"""
        return _SimpleITK.ZeroFluxNeumannPadImageFilter_SetPadLowerBound(self, PadLowerBound)

    def GetPadLowerBound(self):
        r"""GetPadLowerBound(ZeroFluxNeumannPadImageFilter self) -> VectorUInt32"""
        return _SimpleITK.ZeroFluxNeumannPadImageFilter_GetPadLowerBound(self)

    def SetPadUpperBound(self, PadUpperBound):
        r"""SetPadUpperBound(ZeroFluxNeumannPadImageFilter self, VectorUInt32 PadUpperBound)"""
        return _SimpleITK.ZeroFluxNeumannPadImageFilter_SetPadUpperBound(self, PadUpperBound)

    def GetPadUpperBound(self):
        r"""GetPadUpperBound(ZeroFluxNeumannPadImageFilter self) -> VectorUInt32"""
        return _SimpleITK.ZeroFluxNeumannPadImageFilter_GetPadUpperBound(self)

    def GetName(self):
        r"""GetName(ZeroFluxNeumannPadImageFilter self) -> std::string"""
        return _SimpleITK.ZeroFluxNeumannPadImageFilter_GetName(self)

    def __str__(self):
        r"""__str__(ZeroFluxNeumannPadImageFilter self) -> std::string"""
        return _SimpleITK.ZeroFluxNeumannPadImageFilter___str__(self)

    def Execute(self, image1):
        r"""Execute(ZeroFluxNeumannPadImageFilter self, Image image1) -> Image"""
        return _SimpleITK.ZeroFluxNeumannPadImageFilter_Execute(self, image1)

# Register ZeroFluxNeumannPadImageFilter in _SimpleITK:
_SimpleITK.ZeroFluxNeumannPadImageFilter_swigregister(ZeroFluxNeumannPadImageFilter)

def ZeroFluxNeumannPad(*args, **kwargs):
    r"""ZeroFluxNeumannPad(Image image1, VectorUInt32 padLowerBound=std::vector< unsigned int >(3, 0), VectorUInt32 padUpperBound=std::vector< unsigned int >(3, 0)) -> Image"""
    return _SimpleITK.ZeroFluxNeumannPad(*args, **kwargs)
class PyCommand(Command):
    r"""Proxy of C++ slicer_itk::simple::PyCommand class."""

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

    def __init__(self):
        r"""__init__(PyCommand self) -> PyCommand"""
        _SimpleITK.PyCommand_swiginit(self, _SimpleITK.new_PyCommand())
    __swig_destroy__ = _SimpleITK.delete_PyCommand

    def SetCallbackPyCallable(self, obj):
        r"""SetCallbackPyCallable(PyCommand self, PyObject * obj)"""
        return _SimpleITK.PyCommand_SetCallbackPyCallable(self, obj)

    def GetCallbackPyCallable(self):
        r"""GetCallbackPyCallable(PyCommand self) -> PyObject *"""
        return _SimpleITK.PyCommand_GetCallbackPyCallable(self)

    def Execute(self):
        r"""Execute(PyCommand self)"""
        return _SimpleITK.PyCommand_Execute(self)

# Register PyCommand in _SimpleITK:
_SimpleITK.PyCommand_swigregister(PyCommand)

